Prerequisiti - AWS Config
Creazione di un bucket Amazon S3Creare 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 configurareAWScon ilAWS CLI, devi creare un bucket Amazon S3, un argomento Amazon SNS e un ruolo IAM con policy allegate come prerequisiti. A questo punto, potrai utilizzare AWS CLI per specificare bucket, argomento e ruolo per AWS Config. Seguire questa procedura per impostare i prerequisiti perAWS Config.

Creazione di un bucket Amazon S3

Se disponi già di un bucket Amazon S3 nel tuo account e desideri utilizzarlo, puoi ignorare questo passaggio e passare direttamente aCreare un argomento Amazon SNS.

Per creare un bucket

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

  2. Seleziona Create bucket (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 scelto del bucket sia univoco rispetto a tutti i nomi di bucket esistenti in Amazon S3. Per ulteriori informazioni sulle regole e le convenzioni per l'assegnazione di nomi ai bucket, consultaRestrizioni e limitazioni dei bucketnellaGuida utente di Amazon Simple Storage Service.

    Importante

    Evitare di includere informazioni riservate, ad esempio numeri di account, nel nome del bucket. Il nome bucket è visibile nell'URL che punta agli oggetti nel bucket.

  4. In Regione scegliere la Regione AWS in cui si desidera che il bucket risieda.

    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 Regioni AWS di Amazon S3, consulta Endpoint del servizio AWS in 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, consultaUtilizzo di Amazon S3 Blocco dell'accesso pubbliconellaGuida 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, consultareConfigurazione del blocco oggetti 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à Blocco oggetti S3, consultaBlocco di oggetti tramite il blocco oggetti Amazon S3nellaGuida utente di Amazon Simple Storage Service.

  7. Seleziona Create bucket (Crea bucket).

Se utilizzi gli SDK AWS per creare un bucket, devi innanzitutto creare un client e successivamente 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, è necessario specificare una Regione AWS. Per ulteriori informazioni, consultaEndpoint dual-stack Amazon S3. Per un elenco delle Regioni AWS disponibili, consulta Regioni ed endpoint in Riferimenti generali 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, consultaEndpoint legacy.

In questi esempi di SDK AWS vengono eseguite le attività sotto elencate:

  • 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 delle Regioni AWS, consulta Regioni ed endpoint in Riferimenti generali AWS.

  • 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, consultaTest 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, consultaEsecuzione 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, consultaUtilizzo diAWSSDK 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 it's 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

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__

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

Per ulteriori informazioni su AWS CLI, consulta Che cos'è la AWS Command Line Interface? nella Guida per l'utente di AWS Command Line Interface.

Nota

Puoi anche utilizzare un bucket Amazon S3 di un altro account, ma potrebbe essere necessario creare una policy che conceda al bucket le autorizzazioni di accesso aAWS Config. Per informazioni sulla concessione di autorizzazioni a un bucket Amazon S3, consultaAutorizzazioni per il bucket Amazon S3, e poi vai aCreare un argomento Amazon SNS.

Creare un argomento Amazon SNS

Se disponi già di un argomento Amazon SNS nell'account e desideri utilizzarlo, puoi ignorare questo passaggio e passare direttamente aCreazione 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. Completa una delle seguenti operazioni:

    • Se con Account AWS non sono mai stati creati argomenti in precedenza, leggere la descrizione di Amazon SNS nella home page.

    • Se invece sono già stati creati degli argomenti nel Account AWS, nel riquadro di navigazione scegliere Topics (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, consultaDeduplicazione 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, consultaTermini 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 ulteriori informazioni, consulta la .AWS KMSAutorizzazioni API: Riferimento a operazioni e risorsenellaAWS Key Management ServiceGuida per lo Sviluppatore.

      • La CMK gestita da AWS per Amazon SNS (Default) alias/aws/sns è selezionata per impostazione predefinita.

        Nota

        Ricorda:

        • La prima volta che si utilizza AWS Management Console per specificare il CMK di AWS gestito per Amazon SNS per un argomento,AWS KMS crea il CMK gestito da AWS per Amazon SNS.

        • In alternativa, la prima volta che si utilizza un’operazione Publish in un argomento con SSE abilitato, AWS KMS crea il CMK gestita da AWS per Amazon SNS.

      • Per utilizzare una CMK personalizzata dal proprio account AWS, selezionare il campo Chiave master del cliente (CMK) e quindi scegliere il CMK personalizzato dall'elenco.

        Nota

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

      • Per utilizzare un ARN CMK personalizzato dal tuo AWS o da un altro account AWS, inserirlo nel campo Chiave master del cliente (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, consultaIdentity and Access Management in Amazon SNSeEsempi 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, consultaTentativi di consegna dei messaggi di Amazon SNS.

  8. (Facoltativo) Per configurare il modo in cui Amazon SNS logs registra la consegna di messaggi a CloudWatch, espandere la sezione Delivery status logging (Logging stato consegna). Per ulteriori informazioni, consultaStato di consegna dei messaggi 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, consultaAssegnazione di tag all'argomento Amazon SNS.

  10. Scegliere Create topic (Crea argomento).

    L'argomento viene creato e il MyTopic viene visualizzata la pagina.

    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 Kinesis Data Firehose: PerARN del ruolo di abbonamento, specificare l'ARN del ruolo IAM creato per la scrittura nei flussi di distribuzione Kinesis Data Firehose. Per ulteriori informazioni, consultaPrerequisiti per l'iscrizione ai flussi di distribuzione di Kinesis Data Firehose agli argomenti Amazon SNS.

    5. (Facoltativo) Per gli endpoint Kinesis Data Firehose, Amazon SQS, HTTP/S, puoi anche abilitare il recapito dei messaggi non elaborati. Per ulteriori informazioni, consultaConsegna 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, consultaPolicy 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, consultaCode 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 SDK AWS, 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
Suggerimento

Per scoprire come impostare ed eseguire questo esempio, consultare GitHub. 

    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. The example was created
    /// using the AWS SDK for .NET version 3.7 and .NET Core 5.0.
    /// </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;
        }

    }

  • Per informazioni dettagliate sulle API, consulta CreateTopic nella Documentazione di riferimento per le API AWS SDK for .NET.

C++
SDK for C++
Suggerimento

Per scoprire come impostare ed eseguire questo esempio, consultare GitHub. 

  Aws::SDKOptions options;
  Aws::InitAPI(options);
  {
    Aws::String topic_name = argv[1];
    Aws::SNS::SNSClient sns;

    Aws::SNS::Model::CreateTopicRequest ct_req;
    ct_req.SetName(topic_name);

    auto ct_out = sns.CreateTopic(ct_req);

    if (ct_out.IsSuccess())
    {
      std::cout << "Successfully created topic " << topic_name << std::endl;
    }
    else
    {
      std::cout << "Error creating topic " << topic_name << ":" <<
        ct_out.GetError().GetMessage() << std::endl;
    }
  }

  Aws::ShutdownAPI(options);

  • Per informazioni dettagliate sulle API, consulta CreateTopic nella Documentazione di riferimento per le API AWS SDK for C++.

Go
SDK per Go V2
Suggerimento

Per scoprire come impostare ed eseguire questo esempio, consultare GitHub.

  • Per informazioni dettagliate sulle API, consulta CreateTopic nella Documentazione di riferimento per le API AWS SDK for Go.

Java
SDK for Java 2.x
Suggerimento

Per scoprire come impostare ed eseguire questo esempio, consultare GitHub. 

    public static String createSNSTopic(SnsClient snsClient, String topicName ) {

        CreateTopicResponse result = null;
        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 informazioni dettagliate sulle API, consulta CreateTopic nella Documentazione di riferimento per le API AWS SDK for Java 2.x.

JavaScript
SDK per JavaScript V3
Suggerimento

Per scoprire come impostare ed eseguire questo esempio, consultare GitHub.

Creare il client in un modulo separato ed esportarlo.

import  { SNSClient } from "@aws-sdk/client-sns";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create SNS service object.
const snsClient = new SNSClient({ region: REGION });
export  { snsClient };

Importare l'SDK e i moduli client e chiamare l'API.

// Import required AWS SDK clients and commands for Node.js
import {CreateTopicCommand } from "@aws-sdk/client-sns";
import {snsClient } from "./libs/snsClient.js";

// Set the parameters
const params = { Name: "TOPIC_NAME" }; //TOPIC_NAME

const run = async () => {
  try {
    const data = await snsClient.send(new CreateTopicCommand(params));
    console.log("Success.",  data);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err.stack);
  }
};
run();
Kotlin
SDK per Kotlin
Nota

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

Suggerimento

Per scoprire come impostare ed eseguire questo esempio, consultare GitHub. 

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 informazioni dettagliate sulle API, consulta CreateTopic nella Documentazione di riferimento per le API di SDK AWS per Kotlin.

PHP
SDK for PHP
Suggerimento

Per scoprire come impostare ed eseguire questo esempio, consultare GitHub. 

require 'vendor/autoload.php';

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

/**
 * 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)
Suggerimento

Per scoprire come impostare ed eseguire questo esempio, consultare GitHub. 

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 informazioni dettagliate sulle API, consulta CreateTopic nella Documentazione di riferimento per l’API SDK for Python (Boto3) AWS.

Ruby
SDK per Ruby
Suggerimento

Per scoprire come impostare ed eseguire questo esempio, consultare GitHub. 


require 'aws-sdk-sns'  # v2: require 'aws-sdk'

def topic_created?(sns_client, topic_name)

sns_client.create_topic(name: topic_name)
rescue StandardError => e
  puts "Error while creating the topic named '#{topic_name}': #{e.message}"
end

# Full example call:
def run_me
  topic_name = 'TOPIC_NAME'
  region = 'REGION'

  sns_client = Aws::SNS::Client.new(region: region)

  puts "Creating the topic '#{topic_name}'..."

  if topic_created?(sns_client, topic_name)
    puts 'The topic was created.'
  else
    puts 'The topic was not created. Stopping program.'
    exit 1
  end
end

run_me if $PROGRAM_NAME == __FILE__
Rust
SDK per Rust
Nota

Questa documentazione è per un SDK in anteprima. L’SDK è soggetto a modifiche e non deve essere usato in ambiente di produzione.

Suggerimento

Per scoprire come impostare ed eseguire questo esempio, consultare GitHub. 

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 informazioni dettagliate sulle API, consulta CreateTopic nella Documentazione di riferimento degli SDK AWS per l’API Rust.

È possibile utilizzare anche l'AWS Command Line Interface(AWS CLI) per creare un argomento Amazon SNS Per ulteriori informazioni, consultacreate-topicnellaAWS CLIRiferimento ai comandi.

Per ulteriori informazioni su AWS CLI, consulta Che cos'è la AWS Command Line Interface? nella Guida per l'utente di AWS Command Line Interface.

Nota

Puoi anche utilizzare un argomento Amazon SNS in un altro account, ma in questo caso potrebbe essere necessario creare una policy che conceda all'argomento le autorizzazioni di accesso aAWS Config. Per informazioni sulla concessione di autorizzazioni a un argomento Amazon SNS, consultaAutorizzazioni per l'argomento Amazon SNSe poi vai aCreazione di un ruolo IAM.

Creazione di un ruolo IAM

Puoi utilizzare la console IAM per creare un ruolo IAM che concedeAWS Configautorizzazioni per accedere al bucket Amazon S3, accedere al tuo argomento Amazon SNS e ottenere i dettagli di configurazione per il supportoAWSrisorse AWS. Quando utilizzi la console per creare un ruolo IAM,AWS Configcollega automaticamente le autorizzazioni necessarie al ruolo per te.

Per creare un ruolo per unAWSservizio

  1. Accedi alla 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 desideriAWS Config: Config - Personalizzabile,Config - Organizations,Config, oppureConfig - Pacchetto di conformità. Quindi, seleziona Next (Successivo).

  5. SulDenominare, rivedere e creare, consulta i dettagli sul tuo ruolo e scegliCreazione di ruolo.

Per utilizzare un SDK AWS, 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
Suggerimento

Per scoprire come impostare ed eseguire questo esempio, consultare GitHub. 


        /// <summary>
        /// Create a new IAM role which we can attach to a user.
        /// </summary>
        /// <param name="client">The initialized IAM client object.</param>
        /// <param name="roleName">The name of the IAM role to create.</param>
        /// <param name="rolePermissions">The permissions which the role will have.</param>
        /// <returns>A Role object representing the newly created role.</returns>
        public static async Task<Role> CreateRoleAsync(
            AmazonIdentityManagementServiceClient client,
            string roleName,
            string rolePermissions)
        {
            var request = new CreateRoleRequest
            {
                RoleName = roleName,
                AssumeRolePolicyDocument = rolePermissions,
            };

            var response = await client.CreateRoleAsync(request);

            return response.Role;
        }

  • Per informazioni dettagliate, consulta.CreateRolenelAWS SDK for .NETDocumentazione di riferimento API.

Go
SDK per Go V2
Suggerimento

Per scoprire come impostare ed eseguire questo esempio, consultare GitHub. 

	// CreateRole
	myRole, err := service.CreateRole(context.Background(), &iam.CreateRoleInput{
		RoleName:    aws.String(ExampleRoleName),
		Description: aws.String("My super awesome example role"),
		AssumeRolePolicyDocument: aws.String(`{
			"Version": "2012-10-17",
			"Statement": [
			  {
				"Effect": "Allow",
				"Principal": {
				  "Service": "ec2.amazonaws.com"
				},
				"Action": "sts:AssumeRole"
			  }
			]
		  }`),
	})

	if err != nil {
		panic("Couldn't create role: " + err.Error())
	}

	fmt.Println("☑️ Create Role")
	fmt.Printf("The new role's ARN is %s \n", *myRole.Role.Arn)

  • Per informazioni dettagliate, consulta.CreateRolenelAWS SDK for GoDocumentazione di riferimento API.

Java
SDK for Java 2.x
Suggerimento

Per scoprire come impostare ed eseguire questo esempio, consultare GitHub. 

    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 informazioni dettagliate, consulta.CreateRolenelAWS SDK for Java 2.xDocumentazione di riferimento API.

JavaScript
SDK per JavaScript V3
Suggerimento

Per scoprire come impostare ed eseguire questo esempio, consultare GitHub.

Crea il client.

import { IAMClient } from "@aws-sdk/client-iam";
// Set the AWS Region.
const REGION = "REGION"; // For example, "us-east-1".
// Create an IAM service client object.
const iamClient = new IAMClient({ region: REGION });
export { iamClient };

Creare il ruolo.

// Import required AWS SDK clients and commands for Node.js.
import { iamClient } from "./libs/iamClient.js";
import { CreateRoleCommand } from "@aws-sdk/client-iam";

// Sample assume role policy JSON.
const role_json = {
    Version: "2012-10-17",
    Statement: [
        {
            Effect: "Allow",
            Principal: {
                AWS: "USER_ARN", // The ARN of the user.
            },
            Action: "sts:AssumeRole",
        },
    ],
};
// Stringify the assume role policy JSON.
const myJson = JSON.stringify(role_json);

// Set the parameters.
const params = {
    AssumeRolePolicyDocument: myJson,
    Path: "/",
    RoleName: "ROLE_NAME"
};

const run = async () => {
    try {
        const data = await iamClient.send(new CreateRoleCommand(params));
        console.log("Success. Role created. Role Arn: ", data.Role.RoleName);
        } catch (err) {
            console.log("Error", err);
        }
};
run();

  • Per informazioni dettagliate, consulta.CreateRolenelAWS SDK for JavaScriptDocumentazione di riferimento API.

PHP
SDK for PHP
Suggerimento

Per scoprire come impostare ed eseguire questo esempio, consultare GitHub. 

$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 informazioni dettagliate, consulta.CreateRolenelAWS SDK for PHPDocumentazione di riferimento API.

Python
SDK per Python (Boto3)
Suggerimento

Per scoprire come impostare ed eseguire questo esempio, consultare GitHub. 

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 informazioni dettagliate, consulta.CreateRolenelAWSRiferimento API SDK for Python (Boto3).

Ruby
SDK per Ruby
Suggerimento

Per scoprire come impostare ed eseguire questo esempio, consultare GitHub. 

  # Creates a role that can be assumed by a user.
  #
  # @param role_name [String] The name to give the role.
  # @param user [Aws::IAM::User] The user who is granted permission to assume the role.
  # @return [Aws::IAM::Role] The newly created role.
  def create_role(role_name, user)
    role = @iam_resource.create_role(
      role_name: role_name,
      assume_role_policy_document: {
        Version: "2012-10-17",
        Statement: [{
          Effect: "Allow",
          Principal: {'AWS': user.arn},
          Action: "sts:AssumeRole"
        }]
      }.to_json)
    puts("Created role #{role.name}.")
  rescue Aws::Errors::ServiceError => e
    puts("Couldn't create a role for the demo. Here's why: ")
    puts("\t#{e.code}: #{e.message}")
    raise
  else
    role
  end

  • Per informazioni dettagliate, consulta.CreateRolenelAWS SDK for RubyDocumentazione di riferimento API.

Rust
SDK per Rust
Nota

Questa documentazione è per un SDK in anteprima. L’SDK è soggetto a modifiche e non deve essere usato in ambiente di produzione.

Suggerimento

Per scoprire come impostare ed eseguire questo esempio, consultare GitHub. 

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 informazioni dettagliate, consulta.CreateRolenelAWSRiferimento dell'API dell'SDK per Rust.

È possibile utilizzare anche l'AWS Command Line Interface(AWS CLI) per creare un argomento Amazon SNS Per ulteriori informazioni, consultacreate-rolenellaAWS CLIRiferimento ai comandi. A questo punto, potrai collegare una policy al ruolo con il comando attach-role-policy.

Per ulteriori informazioni su AWS CLI, consulta Che cos'è la AWS Command Line Interface? nella Guida per l'utente di AWS Command Line Interface.