Pré-requisitos

Para criar um bucket

Abra o console do Amazon S3 em https://console.aws.amazon.com/s3/.
Selecione Create bucket (Criar bucket).
Em Bucket name (Nome do bucket), insira um nome compatível com o DNS para seu bucket.

O nome do bucket deve:
- Seja exclusivo em todo o Amazon S3.
- Ter entre 3 e 63 caracteres.
- Não contém caracteres maiúsculos.
- Começar com uma letra minúscula ou um número.
Depois de criado o bucket, você não pode mudar seu nome. Certifique-se de que o nome do bucket escolhido seja exclusivo em todos os nomes de bucket existentes no Amazon S3. Para obter mais informações sobre regras e convenções de nomenclatura de buckets, consulteRestrições e limitações do bucketnaGuia do usuário do Amazon Simple Storage Service.

Importante
Evite incluir informações confidenciais, como números de conta, no nome do bucket. O nome do bucket é visível nos URLs que apontam para os objetos no bucket.
Em Region (Região), escolha a região da AWS onde deseja que o bucket resida.

Escolha uma região próxima de você para minimizar a latência e os custos e atender aos requisitos regulatórios. Os objetos armazenados em uma região nunca saem dessa região, a menos que você os transfira para outra região. Para obter uma lista do Amazon S3AWSRegiões, consulteAWSterminais de serviçonaReferência geral da Amazon Web Services.
Em Bucket settings for Block Public Access (Configurações de bucket para o Bloqueio de acesso público), escolha as configurações de bloqueio de acesso público que deseja aplicar ao bucket.

Recomendamos que você deixe todas as configurações ativadas, a menos que saiba que precisa desativar uma ou mais delas para seu caso de uso, como para hospedar um site público. As configurações de bloqueio de acesso público que você habilitar para o bucket também serão ativadas para todos os pontos de acesso criados no bucket. Para obter mais informações sobre como bloquear o acesso público, consulteUsando o Amazon S3 Bloqueie o acesso públiconaGuia do usuário do Amazon Simple Storage Service.
(Opcional) Se você quiser ativar o bloqueio de objetos do S3:
1. Escolha Advanced settings (Configurações avançadas) e leia a mensagem exibida.
  
  Importante
  Você só pode habilitar o bloqueio de objetos do S3 para um bucket ao criá-lo. Se você habilitar o bloqueio de objetos para o bucket, não poderá desabilitá-lo mais tarde. A ativação do bloqueio de objetos também permite o versionamento para o bucket. Depois de habilitar o bloqueio de objetos para o bucket, você deve definir as configurações de bloqueio de objetos antes que qualquer objeto no bucket seja protegido. Para obter mais informações sobre como configurar a proteção para objetos, consulteConfigurando o S3 Object Lock usando o console Amazon S3.
2. Se quiser ativar o bloqueio de objetos, insira enable na caixa de texto e escolha Confirm (Confirmar).
Para obter mais informações sobre o recurso S3 Object Lock, consulteBloqueio de objetos usando o Amazon S3 Object LocknaGuia do usuário do Amazon Simple Storage Service.
Selecione Create bucket (Criar bucket).

Ao usar os AWS SDKs para criar um bucket, você deve criar um cliente e então usá-lo para enviar uma solicitação para criar um bucket. Como prática recomendada, crie o cliente e o bucket na mesma Região da AWS. Se você não especificar uma região ao criar um cliente ou um bucket, o Amazon S3 usará a região padrão Leste dos EUA (Norte da Virgínia).

Para criar um cliente a fim de acessar um endpoint de pilha dupla, é necessário especificar uma Região da AWS. Para obter mais informações, consulteEndpoints de pilha dupla do Amazon S3. Para obter uma lista de Regiões da AWS disponíveis, consulte Regiões e endpoints na Referência geral da AWS.

Ao criar um cliente, a região mapeia para o endpoint específico da região. O cliente usa esse endpoint para se comunicar com o Amazon S3: s3.<region>.amazonaws.com. Se a sua região foi lançada após 20 de março de 2019,, seu cliente e bucket devem estar na mesma região. No entanto, é possível usar um cliente na região Leste dos EUA (Norte da Virgínia) para criar um bucket em qualquer região iniciada antes de 20 de março de 2019. Para obter mais informações, consulteEndpoints antigos.

Os exemplos de código do AWS SDK executam as seguintes tarefas:

Crie um cliente especificando explicitamente uma região da Região da AWS: no exemplo, o cliente usa o endpoint s3.us-west-2.amazonaws.com para se comunicar com o Amazon S3. É possível especificar qualquer Região da AWS. Para obter uma lista de Regiões da AWS, consulte Regiões e endpoints na Referência geral da AWS.
Envie uma solicitação de bucket de criação especificando apenas um nome de bucket — O cliente envia uma solicitação ao Amazon S3 para criar o bucket na região onde você criou um cliente.
Recupere as informações sobre a localização do bucket. O Amazon S3 armazena as informações de localização do bucket no sub-recurso location que está associado ao bucket.

Java

Este exemplo mostra como criar um bucket do Amazon S3 usando o AWS SDK for Java. Para obter instruções sobre como criar e testar uma amostra funcional, consulteTestando os exemplos de código Java do 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

Para obter informações sobre como criar e testar uma amostra funcional, consulteExemplos de código de execução do Amazon S3 .NET.


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

Para obter informações sobre como criar e testar uma amostra funcional, consulteUsando oAWSSDK para Ruby - Versão 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__

Você também pode usar a AWS Command Line Interface (AWS CLI) para criar um bucket do S3. Para obter mais informações, consulte create-bucket na Referência de comandos da AWS CLI.

Para obter informações sobre o AWS CLI, consulte O que é AWS Command Line Interface? no Guia do usuário do AWS Command Line Interface.

Para criar um tópico do Amazon SNS

Abra o console do Amazon SNS em https://console.aws.amazon.com/sns/v3/home.
Faça um dos seguintes procedimentos:
- Se você nunca criou um tópico em sua Conta da AWS, leia a descrição do Amazon SNS na página inicial.
- Se você já criou tópicos em sua Conta da AWS antes, no painel de navegação, selecione Topics (Tópicos).
Na página Topics (Tópicos), escolha Create topic (Criar tópico).
Na página Create topic (Criar tópico), na seção Details (detalhes), faça o seguinte:
1. Em Type (Tipo), escolha um tipo de tópico (Standard (Padrão) ou FIFO).
2. Insira um Name (Nome) para o tópico. Para um tópico FIFO, adicione .fifo ao final do nome.
3. (Opcional) Insira um Display name (Nome para exibição) para o tópico.
4. (Opcional) Para um tópico FIFO, você pode escolher content-based message deduplication (Desduplicação de mensagens baseada em conteúdo) para habilitar a desduplicação de mensagens padrão. Para obter mais informações, consulteDesduplicação de mensagens para tópicos de FIFO.
(Opcional) Expanda a seção Encryption (Criptografia) e faça o seguinte. Para obter mais informações, consulte Criptografia em repouso.
1. Selecione Enable encryption (Ativar criptografia).
2. Especifique a chave mestra de cliente (CMK). Para obter mais informações, consulte Termos de chaves.
  
  Para cada tipo de CMK, a Description (Descrição), a Account (Conta) e o CMK ARN (ARN da CMK) são exibidos.
  
  Importante
  Se você não for o proprietário da CMK ou se fizer login com uma conta que não tenha permissões kms:ListAliases e kms:DescribeKey, não será possível visualizar as informações sobre a CMK no console do Amazon SNS.
  Peça ao proprietário da CMK para conceder essas permissões a você. Para obter mais informações, consulte AWS KMS API Permissions: Actions and Resources Reference (“Permissões da API do KMS: referência de ações e recursos”) no Guia do desenvolvedor do AWS Key Management Service.
  - A CMK gerenciada pela AWS para o Amazon SNS, (Default) alias/aws/sns ((Padrão) alias/aws/sns) é selecionada por padrão.
    nota
    Lembre-se do seguinte:
    
    Na primeira vez que você usar o AWS Management Console para especificar a CMK gerenciada pelas AWS para o Amazon SNS para uma fila, o AWS KMS cria a CMK gerenciada pela AWS para o Amazon SNS.
    
    Alternativamente, na primeira vez que você usar a ação Publish em um tópico com SSE habilitada, o AWS KMS cria a CMK gerenciada pela AWS para o Amazon SNS.
  - Para usar uma CMK personalizada de sua conta da AWS, escolha o campo Customer master key (CMK) (Chave mestra de cliente (CMK)) e, em seguida, escolha a CMK personalizada na lista.
    
    nota
    Para obter instruções sobre como criar CMKs personalizadas, consulte Creating Keys (“Criar chaves”) no Guia do desenvolvedor do AWS Key Management Service.
  - Para usar um ARN de CMK personalizado da sua conta da AWS ou de outra conta da AWS, insira-a no campo Customer master key (CMK) (Chave mestra de cliente (CMK)).
(Opcional) Por padrão, somente o proprietário do tópico pode publicar ou assinar o tópico. Para configurar permissões de acesso adicionais, expanda a seção Política de acesso. Para obter mais informações, consulteGerenciamento de identidade e acesso no Amazon SNSeExemplos de casos de controle de acesso do Amazon SNS.

nota
Quando você cria um tópico usando o console, a política padrão usa a chave de condição aws:SourceOwner. Essa chave é semelhante a aws:SourceAccount.
(Opcional) Para configurar como o Amazon SNS repete tentativas de entrega de mensagem com falha, expanda a seção Delivery retry policy (HTTP/S) (Política de repetição de entrega (HTTP/S)). Para obter mais informações, consulteTentativas de entrega de mensagens do Amazon SNS.
(Opcional) Para configurar como o Amazon SNS registra a entrega de mensagens paraCloudWatch, expanda oRegistro de status de entregaseção. Para obter mais informações, consulteStatus de entrega de mensagens do Amazon SNS.
(Opcional) Para adicionar tags de metadados ao tópico, expanda a seção Tags, insira uma Key (chave) e um Value (Valor) (opcional) e escolha Add tag (Adicionar tag). Para obter mais informações, consulteMarcação de tópicos do Amazon SNS.
Escolha Create topic.

O tópico é criado e oMyTopica página é exibida.

O Name (Nome), o ARN e o Display name (Nome de exibição) (opcional) do tópico, além do ID da conta da AWS do Topic owner (Proprietário do tópico) são exibidos na seção Details (Detalhes).
Copie o ARN do tópico para a área de transferência, por exemplo:
```
arn:aws:sns:us-east-2:123456789012:MyTopic
```

Para inscrever um endereço de e-mail no tópico do Amazon SNS

Abra o console do Amazon SNS em https://console.aws.amazon.com/sns/v3/home.
No painel de navegação à esquerda, escolha Subscriptions (Assinaturas).
Na página Subscriptions (Assinaturas), escolha Create subscription (Criar assinatura).
Na página Create subscription (Criar inscrição), na seção Details (detalhes), faça o seguinte:
1. Em Topic ARN (ARN do tópico), escolha o nome do recurso da Amazon (ARN) de um tópico.
2. Em Protocol (Protocolo), escolha um tipo de endpoint. Os tipos de endpoint disponíveis são:
  - HTTP/HTTPS
  - Email/Email-JSON
  - Amazon Kinesis Data Firehose
  - Amazon SQS
    
    nota
    Para se inscrever em um tópico FIFO do SNS, escolha esta opção.
  - AWS Lambda
  - Endpoint da aplicação da plataforma
  - SMS
3. Em Endpoint, insira o valor do endpoint, como um endereço de e-mail ou o ARN de uma fila do Amazon SQS.
4. Somente pontos finais do Kinesis Data Firehose: em Subscription role ARN (ARN da função de assinatura), especifique o ARN da função do IAM que você criou para gravar em fluxos de entrega do Kinesis Data Firehose. Para obter mais informações, consultePré-requisitos para inscrever streams de entrega do Kinesis Data Firehose nos tópicos do Amazon SNS.
5. (Opcional) Para endpoints HTTP/S, do Kinesis Data Firehose ou do Amazon SQS, você também pode habilitar a entrega de mensagens brutas. Para obter mais informações, consulteEntrega de mensagens brutas do Amazon SNS.
6. (Opcional) Para configurar uma política de filtros, expanda a seção Subscription filter policy (Política de filtro de assinatura). Para obter mais informações, consultePolíticas de filtro de assinatura do Amazon SNS.
7. (Opcional) Para configurar uma fila de mensagens mortas para a assinatura, expanda a seção Redrive policy (dead-letter queue) (Política de redirecionamento (fila de mensagens mortas)). Para obter mais informações, consulteFilas de correspondência (DLQs) do Amazon SNS.
8. Selecione Create subscription.
  
  O console cria a assinatura e abre a página Details (Detalhes) da assinatura.

Para usar um AWS SDK, configure-o com suas credenciais. Para obter mais informações, consulte The shared config and credentials files (“Os arquivos compartilhados de configuração e de credenciais no Guia de referência de AWS SDKs e ferramentas.

Os exemplos de código a seguir mostram como criar um tópico do Amazon SNS.

.NET

AWS SDK for .NET

dica

Para saber como configurar e executar esse exemplo, consulteGitHub.


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

    }

Para obter detalhes da API, consulteCreateTopicemAWS SDK for .NETReferência da API.

C++

SDK para C++

dica

Para saber como configurar e executar esse exemplo, consulteGitHub.


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

Para obter detalhes da API, consulteCreateTopicemAWS SDK for C++Referência da API.

Go

SDK para Go V2

dica

Para saber como configurar e executar esse exemplo, consulteGitHub.

Para obter detalhes da API, consulteCreateTopicemAWS SDK for GoReferência da API.

Java

SDK para Java 2.x

dica

Para saber como configurar e executar esse exemplo, consulteGitHub.


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

Para obter detalhes da API, consulteCreateTopicemAWS SDK for Java 2.xReferência da API.

JavaScript

SDK paraJavaScriptV3

dica

Para saber como configurar e executar esse exemplo, consulteGitHub.

Crie o cliente em um módulo separado e exporte-o.


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

Importe o SDK e os módulos do cliente e chame a 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();

Para obter mais informações, consulte o Guia do desenvolvedor do AWS SDK for JavaScript.
Para obter detalhes da API, consulteCreateTopicemAWS SDK for JavaScriptReferência da API.

Kotlin

SDK para Kotlin

nota

Essa documentação é de pré-lançamento para um recurso em versão de pré-visualização. Está sujeita a alteração.

dica

Para saber como configurar e executar esse exemplo, consulteGitHub.


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

Para obter detalhes da API, consulteCreateTopicemAWSSDK para referência da API Kotlin.

PHP

SDK para PHP

dica

Para saber como configurar e executar esse exemplo, consulteGitHub.


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

Para obter mais informações, consulte o Guia do desenvolvedor do AWS SDK for PHP.
Para obter detalhes da API, consulteCreateTopicemAWS SDK for PHPReferência da API.

Python

SDK para Python (Boto3).

dica

Para saber como configurar e executar esse exemplo, consulteGitHub.


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

Para obter detalhes da API, consulteCreateTopicemAWSReferência da API SDK para Python (Boto3).

Ruby

SDK para Ruby

dica

Para saber como configurar e executar esse exemplo, consulteGitHub.



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__

Para obter mais informações, consulte o Guia do desenvolvedor do AWS SDK for Ruby.
Para obter detalhes da API, consulteCreateTopicemAWS SDK for RubyReferência da API.

Rust

SDK para Rust

nota

Esta documentação destina-se a um SDK na versão de pré-visualização. O SDK está sujeito a alterações e não deve ser usado em ambientes de produção.

dica

Para saber como configurar e executar esse exemplo, consulteGitHub.


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

Para obter detalhes da API, consulteCreateTopicemAWSSDK para referência da API Rust.

Você também pode usar oAWS Command Line Interface(AWS CLI) para criar um tópico do Amazon SNS. Para obter mais informações, consultecriar tópiconaAWS CLIReferência de comando.

Para obter informações sobre o AWS CLI, consulte O que é AWS Command Line Interface? no Guia do usuário do AWS Command Line Interface.

Você pode usar o console do IAM para criar uma função do IAM que concedaAWS Configpermissões para acessar seu bucket do Amazon S3, acessar seu tópico do Amazon SNS e obter detalhes de configuração para obter suporteAWSrecursos. Quando você usa o console para criar uma função do IAM,AWS Configanexa automaticamente as permissões necessárias à função para você.

nota

Se você usou umAWSserviço que usaAWS Config(comoAWSHub de segurança ouAWSTorre de Controle) e umAWS Configa função já foi criada, você deve se certificar de que a função do IAM que você usa ao configurarAWS Configmantém os mesmos privilégios mínimos dos já criadosAWS Configpapel em ordem para o outroAWSserviço para continuar funcionando conforme o esperado.

Por exemplo, seAWSA Control Tower tem uma função de IAM que permiteAWS Configpara ler objetos do Amazon S3, você deve garantir que as mesmas permissões sejam concedidas na função do IAM que você usa ao configurarAWS Config. Caso contrário, isso pode interferir comAWSOperações da Torre de Controle.

Para obter mais informações sobre as funções do IAM paraAWS Config, vejaAWSGerenciamento de identidade e acesso.

Para criar uma função para um serviço da AWS

Faça login no AWS Management Console e abra o console do IAM em https://console.aws.amazon.com/iam/.
No painel de navegação do console do IAM, escolha Roles (Funções) e, em seguida, Create role (Criar função).
Em Select trusted entity (Selecionar entidade confiável), escolha AWS Service (Serviço).
Escolha o caso de uso que você desejaAWS Config:Configuração - Personalizável,Configuração - Organizações,Configuração, ouPacotes de configuração - Conformidade. Em seguida, escolha Next (Próximo).
Sobre oNomeie, analise e criepágina, revise os detalhes sobre sua função e escolhaCriar função.

Para usar um AWS SDK, configure-o com suas credenciais. Para obter mais informações, consulte The shared config and credentials files (“Os arquivos compartilhados de configuração e de credenciais”) no Guia de referência de AWS SDKs e ferramentas.

Os exemplos de código a seguir mostram como criar um perfil do IAM.

.NET

AWS SDK for .NET

dica

Para saber como configurar e executar esse exemplo, consulteGitHub.



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

Para obter detalhes da API, consulteCreateRoleemAWS SDK for .NETReferência da API.

Go

SDK para Go V2

dica

Para saber como configurar e executar esse exemplo, consulteGitHub.


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

Para obter detalhes da API, consulteCreateRoleemAWS SDK for GoReferência da API.

Java

SDK para Java 2.x

dica

Para saber como configurar e executar esse exemplo, consulteGitHub.


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

Para obter detalhes da API, consulteCreateRoleemAWS SDK for Java 2.xReferência da API.

JavaScript

SDK paraJavaScriptV3

dica

Para saber como configurar e executar esse exemplo, consulteGitHub.

Crie o cliente.


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

Crie a função do .


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

Para obter detalhes da API, consulteCreateRoleemAWS SDK for JavaScriptReferência da API.

PHP

SDK para PHP

dica

Para saber como configurar e executar esse exemplo, consulteGitHub.


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

Para obter detalhes da API, consulteCreateRoleemAWS SDK for PHPReferência da API.

Python

SDK para Python (Boto3).

dica

Para saber como configurar e executar esse exemplo, consulteGitHub.


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

Para obter detalhes da API, consulteCreateRoleemAWSReferência da API SDK para Python (Boto3).

Ruby

SDK para Ruby

dica

Para saber como configurar e executar esse exemplo, consulteGitHub.


  # 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

Para obter detalhes da API, consulteCreateRoleemAWS SDK for RubyReferência da API.

Rust

SDK para Rust

nota

Esta documentação destina-se a um SDK na versão de pré-visualização. O SDK está sujeito a alterações e não deve ser usado em ambientes de produção.

dica

Para saber como configurar e executar esse exemplo, consulteGitHub.


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

Para obter detalhes da API, consulteCreateRoleemAWSSDK para referência da API Rust.

Você também pode usar oAWS Command Line Interface(AWS CLI) para criar uma função do IAM. Para obter mais informações, consultecriar funçãonaAWS CLIReferência de comando. Em seguida, você pode anexar uma política à função com oattach-role-policycomando.

Para obter informações sobre o AWS CLI, consulte O que é AWS Command Line Interface? no Guia do usuário do AWS Command Line Interface.

Sumário

Criando um Bucket do Amazon S3

Para criar um bucket

Importante

Importante

nota

Criação de um tópico do Amazon SNS

Para criar um tópico do Amazon SNS

Importante

nota

nota

nota

Para inscrever um endereço de e-mail no tópico do Amazon SNS

nota

dica

dica

dica

dica

dica

nota

dica

dica

dica

dica

nota

dica

nota

Criar uma função do IAM

nota

Para criar uma função para um serviço da AWS

dica

dica

dica

dica

dica

dica

dica

nota

dica