Etapa 1: Criação de um bucket do Amazon S3 Etapa 2: Criando um SNS tópico na Amazon Etapa 3: Criar uma IAM função

Pré-requisitos para configuração com o AWS ConfigAWS CLI

Antes de configurar AWS com o AWS CLI, você precisa criar um bucket do Amazon S3, um SNS tópico da Amazon e uma IAM função com políticas anexadas como pré-requisitos. Em seguida, você pode usar o AWS CLI para especificar o bucket, o tópico e a função do AWS Config. Siga este procedimento para configurar seus pré-requisitos para o AWS Config.

Tópicos

Etapa 1: Criação de um bucket do Amazon S3
Etapa 2: Criando um SNS tópico na Amazon
Etapa 3: Criar uma IAM função

Etapa 1: Criação de um bucket do Amazon S3

Se você já tem um bucket do S3 em sua conta e deseja usá-lo, ignore esta etapa e vá para Etapa 2: Criando um SNS tópico na Amazon.

Para criar um bucket

Abra o console do Amazon S3 em. https://console.aws.amazon.com/s3/
Selecione Criar bucket.
Em Nome do bucket, insira um nome DNS compatível com -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. Garanta que o nome do bucket escolhido seja exclusivo entre todos os nomes de buckets existentes no Amazon S3. Para obter mais informações sobre as regras e convenções de nomeação buckets, consulte Restrições e limitações de buckets no Guia do usuário do Amazon Simple Storage Service.

Importante
Evite incluir informações confidenciais no nome do bucket. O nome do bucket é visível URLs nesse ponto para os objetos no bucket.
Em Região, escolha a AWS região em que você 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 das AWS regiões do Amazon S3, consulte os endpoints AWS de serviço no. Referê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, consulte Usar o bloqueio de acesso público do Amazon S3 no Guia 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 de objetos, consulte Configurar o bloqueio de objetos do S3 usando o console do 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 Bloqueio de Objetos do S3, consulte Usar o bloqueio de objetos do S3 no Guia do usuário do Amazon Simple Storage Service.
Selecione Criar bucket.

Ao usar o AWS SDKs para criar um bucket, você deve criar um cliente e depois usar o cliente 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 para acessar um endpoint de pilha dupla, você deve especificar um. Região da AWS Para obter mais informações, consulte Endpoints de pilha dupla do Amazon S3. Para obter uma lista dos disponíveis Regiões da AWS, consulte Regiões e endpoints no 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, consulte Endpoints herdados.

Esses exemplos AWS SDK de código 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 AWS geral.
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.

Os exemplos de código a seguir mostram como usar o CreateBucket.

.NET

AWS SDK for .NET

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da AWS.



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

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

Crie um bucket com o bloqueio de objetos habilitado.


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

            var response = await _amazonS3.PutBucketAsync(request);

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

Para API obter detalhes, consulte CreateBucketem AWS SDK for .NET APIReferência.

Bash

AWS CLI com script Bash

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da AWS.


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

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

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

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

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

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

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

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

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

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

  # shellcheck disable=SC2181
  if [[ ${?} -ne 0 ]]; then
    errecho "ERROR: AWS reports create-bucket operation failed.\n$response"
    return 1
  fi
}

Para API obter detalhes, consulte CreateBucketna Referência de AWS CLI Comandos.

C++

SDKpara C++

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da AWS.


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

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

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

    return outcome.IsSuccess();
}

Para API obter detalhes, consulte CreateBucketem AWS SDK for C++ APIReferência.

CLI

AWS CLI

Exemplo 1: como criar um bucket

O seguinte exemplo de create-bucket cria um bucket chamado my-bucket:


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

Saída:


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

Para obter mais informações, consulte Como criar um bucket no Guia do usuário do Amazon S3.

Exemplo 2: como criar um bucket com aplicação de políticas de proprietário

O exemplo de create-bucket a seguir cria um bucket chamado my-bucket que usa a configuração aplicada de proprietário de bucket para a propriedade de objetos do S3.


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

Saída:


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

Para obter mais informações, consulte Controle de propriedade de objetos e desativação ACLs no Guia do usuário do Amazon S3.

Exemplo 3: como criar um bucket fora da região ``us-east-1``

O exemplo de create-bucket a seguir cria um bucket chamado my-bucket na região eu-west-1. Regiões fora da us-east-1 exigem que o LocationConstraint adequado seja especificado para poder criar o bucket na região desejada.


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

Saída:


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

Para obter mais informações, consulte Como criar um bucket no Guia do usuário do Amazon S3.

Para API obter detalhes, consulte CreateBucketna Referência de AWS CLI Comandos.

Go

SDKpara Go V2

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da AWS.

Criar um bucket com a configuração padrão.



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



// CreateBucket creates a bucket with the specified name in the specified Region.
func (basics BucketBasics) CreateBucket(name string, region string) error {
	_, err := basics.S3Client.CreateBucket(context.TODO(), &s3.CreateBucketInput{
		Bucket: aws.String(name),
		CreateBucketConfiguration: &types.CreateBucketConfiguration{
			LocationConstraint: types.BucketLocationConstraint(region),
		},
	})
	if err != nil {
		log.Printf("Couldn't create bucket %v in Region %v. Here's why: %v\n",
			name, region, err)
	}
	return err
}

Crie um bucket com bloqueio de objetos e espere que ele exista.



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



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

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

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

	return bucket, err
}

Para API obter detalhes, consulte CreateBucketem AWS SDK for Go APIReferência.

Java

SDKpara Java 2.x

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da AWS.

Crie um bucket.


import software.amazon.awssdk.core.waiters.WaiterResponse;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.CreateBucketRequest;
import software.amazon.awssdk.services.s3.model.HeadBucketRequest;
import software.amazon.awssdk.services.s3.model.HeadBucketResponse;
import software.amazon.awssdk.services.s3.model.S3Exception;
import software.amazon.awssdk.services.s3.waiters.S3Waiter;
import java.net.URISyntaxException;

/**
 * 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 CreateBucket {
    public static void main(String[] args) throws URISyntaxException {
        final String usage = """

                Usage:
                    <bucketName>\s

                Where:
                    bucketName - The name of the bucket to create. The bucket name must be unique, or an error occurs.
                """;

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

        String bucketName = args[0];
        System.out.format("Creating a bucket named %s\n", bucketName);
        Region region = Region.US_EAST_1;
        S3Client s3 = S3Client.builder()
                .region(region)
                .build();

        createBucket(s3, bucketName);
        s3.close();
    }

    public static void createBucket(S3Client s3Client, String bucketName) {
        try {
            S3Waiter s3Waiter = s3Client.waiter();
            CreateBucketRequest bucketRequest = CreateBucketRequest.builder()
                    .bucket(bucketName)
                    .build();

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

            // Wait until the bucket is created and print out the response.
            WaiterResponse<HeadBucketResponse> waiterResponse = s3Waiter.waitUntilBucketExists(bucketRequestWait);
            waiterResponse.matched().response().ifPresent(System.out::println);
            System.out.println(bucketName + " is ready");

        } catch (S3Exception e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }
}

Crie um bucket com o bloqueio de objetos habilitado.


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

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

        // Wait until the bucket is created and print out the response.
        s3Waiter.waitUntilBucketExists(bucketRequestWait);
        System.out.println(bucketName + " is ready");
    }

Para API obter detalhes, consulte CreateBucketem AWS SDK for Java 2.x APIReferência.

JavaScript

SDKpara JavaScript (v3)

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da AWS.

Crie o bucket.


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

const client = new S3Client({});

export const main = async () => {
  const command = new CreateBucketCommand({
    // The name of the bucket. Bucket names are unique and have several other constraints.
    // See https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html
    Bucket: "bucket-name",
  });

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

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

Kotlin

SDKpara Kotlin

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da AWS.


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

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

Para API obter detalhes, consulte a CreateBucketreferência AWS SDKdo Kotlin API.

PHP

SDK para PHP

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da AWS.

Crie um bucket.


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

        try {
            $this->s3client->createBucket([
                'Bucket' => $this->bucketName,
                'CreateBucketConfiguration' => ['LocationConstraint' => $region],
            ]);
            echo "Created bucket named: $this->bucketName \n";
        } catch (Exception $exception) {
            echo "Failed to create bucket $this->bucketName with error: " . $exception->getMessage();
            exit("Please fix error with bucket creation before continuing.");
        }

Para API obter detalhes, consulte CreateBucketem AWS SDK for PHP APIReferência.

Python

SDKpara Python (Boto3)

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da AWS.

Crie um bucket com as configurações padrão.


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

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


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

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

            self.bucket.wait_until_exists()
            logger.info("Created bucket '%s' in region=%s", self.bucket.name, region)
        except ClientError as error:
            logger.exception(
                "Couldn't create bucket named '%s' in region=%s.",
                self.bucket.name,
                region,
            )
            raise error

Crie um bucket versionado com uma configuração de ciclo de vida.


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

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

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

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

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

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

    return bucket

Para API obter detalhes, consulte a CreateBucketReferência AWS SDK do Python (Boto3). API

Ruby

SDKpara Ruby

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da AWS.


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__

Para API obter detalhes, consulte CreateBucketem AWS SDK for Ruby APIReferência.

Rust

SDKpara Rust

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da AWS.


pub async fn create_bucket(
    client: &Client,
    bucket_name: &str,
    region: &str,
) -> Result<CreateBucketOutput, SdkError<CreateBucketError>> {
    let constraint = BucketLocationConstraint::from(region);
    let cfg = CreateBucketConfiguration::builder()
        .location_constraint(constraint)
        .build();
    client
        .create_bucket()
        .create_bucket_configuration(cfg)
        .bucket(bucket_name)
        .send()
        .await
}

Para API obter detalhes, consulte CreateBucketa AWS SDKAPIreferência do Rust.

SAP ABAP

SDKpara SAP ABAP

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da AWS.


    TRY.
        lo_s3->createbucket(
            iv_bucket = iv_bucket_name
        ).
        MESSAGE 'S3 bucket created.' TYPE 'I'.
      CATCH /aws1/cx_s3_bucketalrdyexists.
        MESSAGE 'Bucket name already exists.' TYPE 'E'.
      CATCH /aws1/cx_s3_bktalrdyownedbyyou.
        MESSAGE 'Bucket already exists and is owned by you.' TYPE 'E'.
    ENDTRY.

Para API obter detalhes, consulte CreateBucket AWSSDKpara SAP ABAP API referência.

Swift

SDKpara Swift

nota

Esta é a documentação de pré-lançamento de uma SDK versão prévia. Está sujeita a alteração.

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da AWS.


    public func createBucket(name: String) async throws {
        let config = S3ClientTypes.CreateBucketConfiguration(
            locationConstraint: .usEast2
        )
        let input = CreateBucketInput(
            bucket: name,
            createBucketConfiguration: config
        )
        _ = try await client.createBucket(input: input)
    }

Para API obter detalhes, consulte CreateBucketa APIreferência AWS SDK do Swift.

nota

Você também pode usar um bucket do Amazon S3 de uma conta diferente, mas pode ser necessário criar uma política para o bucket que conceda permissões de acesso para o AWS Config. Para obter informações sobre a concessão de permissões para um bucket do S3, consulte Permissões para o bucket Amazon S3 para o AWS Config canal de entrega e, em seguida, vá para Etapa 2: Criando um SNS tópico na Amazon.

Etapa 2: Criando um SNS tópico na Amazon

Se você já tem um SNS tópico da Amazon em sua conta e quer usá-lo, pule esta etapa e vá paraEtapa 3: Criar uma IAM função.

Para criar um SNS tópico na Amazon

Abra o SNS console da Amazon em https://console.aws.amazon.com/sns/v3/home.
Execute um destes procedimentos:
- Se nenhum tópico foi criado Conta da AWS antes, leia a descrição da Amazon SNS na página inicial.
- Se os tópicos já tiverem sido criados abaixo Conta da AWS do seu, no painel de navegação, escolha 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 Tipo, escolha um tipo de tópico (Padrão ou FIFO).
2. Insira um Name (Nome) para o tópico. Para um FIFOtópico, adicione.fifo ao final do nome.
3. (Opcional) Insira um Display name (Nome para exibição) para o tópico.
4. (Opcional) Para um FIFO tópico, você pode escolher a desduplicação de mensagens baseada em conteúdo para habilitar a desduplicação de mensagens padrão. Para obter mais informações, consulte Desduplicação de mensagens para FIFO ver os tópicos.
(Opcional) Expanda a seção Encryption (Criptografia) e faça o seguinte. Para obter mais informações, consulte Criptografia em repouso.
1. Selecione Ativar criptografia.
2. Especifique a chave mestra do cliente (CMK). Para obter mais informações, consulte Termos de chaves.
  
  Para cada CMK tipo, a Descrição, a Conta e CMKARNsão exibidos.
  
  Importante
  Se você não for o proprietário doCMK, ou se fizer login com uma conta que não tenha as kms:DescribeKey permissões kms:ListAliases e, você não poderá visualizar informações sobre o CMK no SNS console da Amazon.
  Peça ao proprietário do que CMK lhe conceda essas permissões. Para obter mais informações, consulte a Referência de AWS KMS API permissões: ações e recursos no Guia do AWS Key Management Service desenvolvedor.
  - O alias/aws/sns AWS gerenciado CMK para a Amazon SNS (padrão) é selecionado por padrão.
    nota
    Lembre-se do seguinte:
    
    A primeira vez que você usa o AWS Management Console para especificar o AWS gerenciado CMK para a Amazon SNS para um tópico, AWS KMS cria o AWS gerenciado CMK para a AmazonSNS.
    
    Como alternativa, na primeira vez em que você usa a Publish ação em um tópico com SSE ativada, AWS KMS cria a ação AWS gerenciada CMK para a AmazonSNS.
  - Para usar uma personalizada CMK da sua Conta da AWS, escolha o campo Chave mestra do cliente (CMK) e, em seguida, escolha a personalizada na CMK lista.
    
    nota
    Para obter instruções sobre como criar chaves personalizadasCMKs, consulte Criação de chaves no Guia do AWS Key Management Service desenvolvedor
  - Para usar uma conta personalizada CMK ARN da sua Conta da AWS ou de outra AWS conta, insira-a no campo Chave mestra do 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, consulte Gerenciamento de identidade e acesso na Amazon SNS e exemplos de casos para controle de SNS acesso da Amazon.

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 a Amazon SNS tenta novamente tentativas malsucedidas de entrega de mensagens, expanda a seção Política de nova tentativa de entrega (HTTP/S). Para obter mais informações, consulte Tentativas de entrega de SNS mensagens da Amazon.
(Opcional) Para configurar como a Amazon SNS registra a entrega de mensagens CloudWatch, expanda a seção Registro de status de entrega. Para obter mais informações, consulte o status de entrega de SNS mensagens da Amazon.
(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, consulte Marcação de SNS tópicos da Amazon.
Escolha Criar tópico.

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

O nome do tópico ARN, o nome de exibição (opcional) e o ID da AWS conta do proprietário do tópico são exibidos na seção Detalhes.
Copie o tópico ARN 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 SNS tópico da Amazon

Abra o SNS console da Amazon em https://console.aws.amazon.com/sns/v3/home.
No painel de navegação à esquerda, escolha 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. ARNEm Tópico, escolha o Amazon Resource Name (ARN) de um tópico.
2. Em Protocol (Protocolo), escolha um tipo de endpoint. Os tipos de endpoint disponíveis são:
  - HTTP/HTTPS
  - E-mail/E-mail- JSON
  - Amazon Data Firehose
  - Amazon SQS
    
    nota
    Para assinar um SNSFIFOtópico, escolha essa 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 da AmazonSQS.
4. Somente endpoints do Firehose: para a função Subscription ARN, especifique a IAM função que você criou para gravar nos streams ARN de entrega do Firehose. Para obter mais informações, consulte Pré-requisitos para inscrever streams de entrega do Firehose nos tópicos da Amazon. SNS
5. (Opcional) Para endpoints FirehoseSQS, Amazon, HTTP /S, você também pode ativar a entrega de mensagens brutas. Para obter mais informações, consulte Entrega de mensagens SNS brutas da Amazon.
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, consulte as políticas de filtro de SNS assinatura da Amazon.
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, consulte Amazon SNS dead-letter queues (). DLQs
8. Selecione Create subscription.
  
  O console cria a assinatura e abre a página Details (Detalhes) da assinatura.

Para usar um AWS SDK, você deve configurá-lo com suas credenciais. Para obter mais informações, consulte Os arquivos compartilhados de configuração e credenciais no Guia de referência de ferramentas AWS SDKs e ferramentas.

Os exemplos de código a seguir mostram como usar o CreateTopic.

.NET

AWS SDK for .NET

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da AWS.

Crie um tópico com um nome específico.


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

Crie um novo tópico com um nome e atributos específicos FIFO e de eliminação de duplicação.


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

Para API obter detalhes, consulte CreateTopicem AWS SDK for .NET APIReferência.

C++

SDKpara C++

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da 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();
}

Para API obter detalhes, consulte CreateTopicem AWS SDK for C++ APIReferência.

CLI

AWS CLI

Para criar um tópico do SNS

O create-topic exemplo a seguir cria um SNS tópico chamadomy-topic.


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

Saída:


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

Para obter mais informações, consulte Usando a interface de linha de AWS comando com a Amazon SQS e a Amazon SNS no Guia do usuário da interface de linha de AWS comando.

Para API obter detalhes, consulte CreateTopicna Referência de AWS CLI Comandos.

Go

SDKpara Go V2

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da 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
}

Para API obter detalhes, consulte CreateTopicem AWS SDK for Go APIReferência.

Java

SDKpara Java 2.x

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da 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 "";
    }
}

Para API obter detalhes, consulte CreateTopicem AWS SDK for Java 2.x APIReferência.

JavaScript

SDKpara JavaScript (v3)

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da AWS.

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


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

Importe os módulos SDK e do cliente e chame API o.


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

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

Kotlin

SDKpara Kotlin

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da 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()
    }
}

Para API obter detalhes, consulte a CreateTopicreferência AWS SDKdo Kotlin API.

PHP

SDK para PHP

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da 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());
}

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

Python

SDKpara Python (Boto3)

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da 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

Para API obter detalhes, consulte a CreateTopicReferência AWS SDK do Python (Boto3). API

Ruby

SDKpara Ruby

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da 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

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

Rust

SDKpara Rust

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da 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(())
}

Para API obter detalhes, consulte CreateTopica AWS SDKAPIreferência do Rust.

SAP ABAP

SDKpara SAP ABAP

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da 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.

Para API obter detalhes, consulte CreateTopic AWSSDKpara SAP ABAP API referência.

nota

Você também pode usar um SNS tópico da Amazon em uma conta diferente, mas, nesse caso, talvez seja necessário criar uma política para o tópico que conceda permissões de acesso AWS Config a. Para obter informações sobre como conceder permissões para um SNS tópico da Amazon, consulte Permissões para o SNS tópico da Amazon e acesseEtapa 3: Criar uma IAM função.

Etapa 3: Criar uma IAM função

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

nota

Se você usou um AWS serviço que usa AWS Config (como AWS Security Hub ou AWS Control Tower) e uma AWS Config função já foi criada, certifique-se de que a IAM função usada durante a configuração AWS Config mantenha os mesmos privilégios mínimos da AWS Config função já criada para que o outro AWS serviço continue sendo executado conforme o esperado.

Por exemplo, se a AWS Control Tower tiver uma IAM função que AWS Config permita ler objetos do Amazon S3, você deve garantir que as mesmas permissões sejam concedidas dentro da IAM função que você usa ao configurar. AWS Config Caso contrário, isso pode interferir nas operações da Torre de AWS Controle.

Para obter mais informações sobre IAM funções para AWS Config, consulte AWS Identity and Access Management.

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

Faça login no AWS Management Console e abra o IAM console em https://console.aws.amazon.com/iam/.
No painel de navegação do IAM console, escolha Funções e, em seguida, escolha Criar função.
Em Select trusted entity (Selecionar entidade confiável), escolha AWS Service (Serviço).
Escolha o caso de uso que você deseja para AWS Config: Config - Customizable, Config - Organizations, Config ou Config - Conformance Packs. Em seguida, escolha Próximo.
Na página Nomear, revisar e criar, analise os detalhes do perfil e selecione Criar perfil.

Os exemplos de código a seguir mostram como usar o CreateRole.

.NET

AWS SDK for .NET

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da 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;
    }

Para API obter detalhes, consulte CreateRoleem AWS SDK for .NET APIReferência.

Bash

AWS CLI com script Bash

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da 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
}

Para API obter detalhes, consulte CreateRolena Referência de AWS CLI Comandos.

C++

SDKpara C++

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da 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();
}

Para API obter detalhes, consulte CreateRoleem AWS SDK for C++ APIReferência.

CLI

AWS CLI

Exemplo 1: Para criar uma IAM função

O comando create-role, apresentado a seguir, cria um perfil, denominado Test-Role, e anexa uma política de confiança a ele.


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

Saída:


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

A política de confiança é definida como um JSON documento no arquivo Test-role-trust-policy.json. (O nome e a extensão do arquivo não têm significado.) A política de confiança deve especificar uma entidade principal.

Para anexar uma política de permissões a um perfil, use o comando put-role-policy.

Para obter mais informações, consulte Criação de IAM funções no Guia AWS IAM do usuário.

Exemplo 2: Para criar uma IAM função com duração máxima de sessão especificada

O comando create-role, apresentado a seguir, cria um perfil denominado Test-Role e define a duração máxima da sessão como 7.200 segundos (duas horas).


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

Saída:


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

Para obter mais informações, consulte Modificar a duração máxima da sessão de uma função (AWS API) no Guia do AWS IAM usuário.

Exemplo 3: Para criar uma IAM função com tags

O comando a seguir cria uma IAM função Test-Role com tags. Este exemplo usa o sinalizador de --tags parâmetro com as seguintes tags JSON formatadas:. '{"Key": "Department", "Value": "Accounting"}' '{"Key": "Location", "Value": "Seattle"}' Como alternativa, o sinalizador --tags pode ser usado com etiquetas no formato abreviado: '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"}'

Saída:


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

Para obter mais informações, consulte Como marcar IAM funções no Guia do AWS IAM usuário.

Para API obter detalhes, consulte CreateRolena Referência de AWS CLI Comandos.

Go

SDKpara Go V2

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da 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
}

Para API obter detalhes, consulte CreateRoleem AWS SDK for Go APIReferência.

Java

SDKpara Java 2.x

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da 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);
    }
}

Para API obter detalhes, consulte CreateRoleem AWS SDK for Java 2.x APIReferência.

JavaScript

SDKpara JavaScript (v3)

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da AWS.

Crie a função.


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

Para API obter detalhes, consulte CreateRoleem AWS SDK for JavaScript APIReferência.

PHP

SDK para PHP

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da 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'];
    }

Para API obter detalhes, consulte CreateRoleem AWS SDK for PHP APIReferência.

PowerShell

Ferramentas para PowerShell

Exemplo 1: este exemplo cria um perfil denominado MyNewRole e anexa a ele a política encontrada no arquivo NewRoleTrustPolicy.json. Observe que você deve usar o parâmetro -Raw switch para processar com êxito o arquivo JSON de política. O documento de política exibido na saída é URL codificado. Ele é decodificado neste exemplo com o. UrlDecode NETmétodo.


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

Saída:


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

[System.Reflection.Assembly]::LoadWithPartialName("System.Web.HttpUtility")
[System.Web.HttpUtility]::UrlDecode($results.AssumeRolePolicyDocument)
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "",
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::123456789012:David"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}

Para API obter detalhes, consulte CreateRoleem Referência de AWS Tools for PowerShell cmdlet.

Python

SDKpara Python (Boto3)

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da 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

Para API obter detalhes, consulte a CreateRoleReferência AWS SDK do Python (Boto3). API

Ruby

SDKpara Ruby

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da 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

Para API obter detalhes, consulte CreateRoleem AWS SDK for Ruby APIReferência.

Rust

SDKpara Rust

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da 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())
}

Para API obter detalhes, consulte CreateRolea AWS SDKAPIreferência do Rust.

Swift

SDKpara Swift

nota

Esta é a documentação de pré-lançamento de uma SDK versão prévia. Está sujeita a alteração.

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no Repositório de exemplos de código da 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
        }
    }

Para API obter detalhes, consulte CreateRolea APIreferência AWS SDK do Swift.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Configurando (AWS CLI)

Começando AWS Config

Pré-requisitos para configuração com o AWS ConfigAWS CLI

Tópicos

Etapa 1: Criação de um bucket do Amazon S3

Para criar um bucket

Importante

Importante

nota

nota

nota

nota

nota

nota

nota

nota

nota

nota

nota

nota

nota

nota

nota

Etapa 2: Criando um SNS tópico na Amazon

Para criar um SNS tópico na Amazon

Importante

nota

nota

nota

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

nota

nota

nota

nota

nota

nota

nota

nota

nota

nota

nota

nota

nota

Etapa 3: Criar uma IAM função

nota

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

nota

nota

nota

nota

nota

nota

nota

nota

nota

nota

nota

nota