AWS Config 使用設定的先決條件 AWS CLI

在設 AWS 定之前 AWS CLI，您需要建立 Amazon S3 儲存貯體、Amazon SNS 主題以及具有附加政策的IAM角色做為先決條件。然後，您可以使用 AWS CLI 來指定的值區、主題和角色 AWS Config。請遵循此程序設定 AWS Config的先決條件。

第 1 步：創建一個 Amazon S3 存儲桶

如果帳戶中已有想要使用的 Amazon S3 儲存貯體，請跳過此步驟，前往《第 2 步：創建一個 Amazon SNS 主題》。

使用 S3 主控台

建立儲存貯體

1. 在開啟 Amazon S3 主控台https://console.aws.amazon.com/s3/。

2. 選擇建立儲存貯體。

3. 在值區名稱中，輸入值區DNS相容的名稱。

   儲存貯體名稱必須；

   • 在所有 Amazon S3 中都為唯一。

   • 長度必須介於 3 與 63 個字元之間。

   • 不含大寫字元。

   • 以小寫字母或數字開頭。

   建立儲存貯體後，便無法變更其名稱。確認您選擇的儲存貯體名稱在 Amazon S3 所有的現有儲存貯體名稱中是唯一的。如需儲存貯體命名規則和慣例的詳細資訊，請參閱《Amazon Simple Storage Service 使用者指南》中的《儲存貯體法規與限制》。

   重要

   避免在值區名稱中包含敏感資訊。值區名稱會顯URLs示在值區中的物件。

4. 在「地區」中，選擇您要儲存貯體所在的「 AWS 區域」。

   建議您選擇接近您的區域以充分降低延遲及成本，並因應法規要求。除非您明確地將存放在區域中的物件傳輸到其他區域，否則物件絕對不會離開該區域。如需 Amazon S3 AWS 區域的清單，請參閱AWS Amazon Web Services 一般參考.

5. 在 Bucket settings for Block Public Access (封鎖公開存取的儲存貯體設定) 中，選擇要套用至儲存貯體的封鎖公開存取設定。

   除非您知道您需要針對使用案例關閉一或多個設定，例如託管公有網站，否則建議您將所有設定保持啟用狀態。另外針對您在儲存貯體上建立的所有存取點，也會啟用封鎖公開存取設定。如需有關封鎖公開存取的詳細資訊，請參閱《Amazon Simple Storage Service 使用者指南》中的《使用 Amazon S3 封鎖公開存取》。

6. (選用) 如果您要啟用 S3 物件鎖定：

   1. 選擇 Advanced settings (進階設定)，然後閱讀出現的訊息。

      重要

      您只能在建立儲存貯體時啟用 S3 物件鎖定。如果您啟用儲存貯體的物件鎖定，稍後無法加以停用。啟用物件鎖定也會啟用儲存貯體的版本控制。啟用儲存貯體的物件鎖定後，您必須先設定物件鎖定設定，之後才能保護儲存貯體中的任何物件。如需設定物件防護的詳細資訊，請參閱《使用 Amazon S3 主控台設定 S3 物件鎖定》。

   2. 如果要啟用物件鎖定，請在文字方塊中輸入啟用，然後選擇確認。

   如需 S3 物件鎖定功能的詳細資訊，請參閱《Amazon Simple Storage Service 使用者指南》中的《使用 Amazon S3 物件鎖定功能鎖定物件》。

7. 選擇建立儲存貯體。

使用 AWS SDKs

使用建立值區時，必須建立用戶端，然後使用用戶端傳送要求以建立值區。 AWS SDKs最佳實務是，您應該在同一個 AWS 區域中建立用戶端和儲存貯體。如果您在建立用戶端或儲存貯體時未指定區域，則 Amazon S3 會使用預設的美國東部 (維吉尼亞北部) 區域。

若要建立用戶端以存取雙堆疊端點，您必須指定 AWS 區域. 如需詳細資訊，請參閱《Amazon S3 雙堆疊端點》。如需可用的清單 AWS 區域，請參閱中的區域和端點AWS 一般參考。

建立用戶端時，區域會對應至區域特定的端點。用戶端會使用此端點來與 Amazon S3：s3.<region>.amazonaws.com 通訊。如果您的區域在 2019 年 3 月 20 日之後啟動，您的用戶端和儲存貯體必須位於相同區域中。不過，您可以在美國東部 (維吉尼亞北部) 區域中使用用戶端，以便在 2019 年 3 月 20 日之前推出的任何區域中建立儲存貯體。如需詳細資訊，請參閱《舊版端點》。

這些 AWS SDK程式碼範例會執行下列工作：

• 透過明確指定 AWS 區域 來建立用戶端 – 在此範例中，用戶端使用 s3.us-west-2.amazonaws.com 端點與 Amazon S3 通訊。您可指定任何 AWS 區域。如需的清單 AWS 區域，請參閱AWS 一般參考中的區域和端點。

• 透過僅指定儲存貯體名稱來傳送建立儲存貯體 要求 — 用戶端會向 Amazon S3 傳送要求，以在您建立用戶端的區域中建立儲存貯體。

• 擷取儲存貯體位置的相關資訊 — Amazon S3 會將儲存貯體位置資訊存放在與儲存貯體相關聯的 location 子資源中。

下列程式碼範例會示範如何使用CreateBucket。

.NET

AWS SDK for .NET

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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;
            }
        }

建立啟用物件鎖定的值區。

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

• 如需詳API細資訊，請參閱AWS SDK for .NET API參考CreateBucket中的。

Bash

AWS CLI 使用 Bash 腳本

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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
}

• 如需詳API細資訊，請參閱AWS CLI 指令參考CreateBucket中的。

C++

SDK對於 C ++

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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();
}

• 如需詳API細資訊，請參閱AWS SDK for C++ API參考CreateBucket中的。

CLI

AWS CLI

範例 1：若要建立值區

下列create-bucket範例會建立名為的值區my-bucket：

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

輸出：

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

如需詳細資訊，請參閱 Amazon S3 使用者指南中的建立儲存貯體。

範例 2：若要建立強制擁有者的值區

下列create-bucket範例會建立名my-bucket為使用 S3 物件擁有權強制執行儲存貯體擁有者設定的儲存貯體。

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

輸出：

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

如需詳細資訊，請參閱 Amazon S3 使用者指南ACLs中的控制物件擁有權和停用。

範例 3：在「us-east-1」區域之外建立值區

下列create-bucket範例會建立區域my-bucket中名為的值eu-west-1區。位於以外的區域us-east-1需要指定適當LocationConstraint的區域，才能在所需的區域中建立值區。

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

輸出：

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

如需詳細資訊，請參閱 Amazon S3 使用者指南中的建立儲存貯體。

• 如需詳API細資訊，請參閱AWS CLI 指令參考CreateBucket中的。

Go

SDK對於轉到 V2

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 AWS 程式碼範例儲存庫中設定和執行。

使用預設組態建立值區。

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

建立具有物件鎖定的值區，並等待它存在。

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

• 如需詳API細資訊，請參閱AWS SDK for Go API參考CreateBucket中的。

Java

SDK對於爪哇 2.x

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 AWS 程式碼範例儲存庫中設定和執行。

建立儲存貯體。

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

建立啟用物件鎖定的值區。

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

• 如需詳API細資訊，請參閱AWS SDK for Java 2.x API參考CreateBucket中的。

JavaScript

SDK對於 JavaScript （3）

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 AWS 程式碼範例儲存庫中設定和執行。

建立儲存貯體。

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

• 如需詳細資訊，請參閱《AWS SDK for JavaScript 開發人員指南》。

• 如需詳API細資訊，請參閱AWS SDK for JavaScript API參考CreateBucket中的。

Kotlin

SDK對於科特林

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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")
    }
}

• 有API關詳細資訊，請參閱CreateBucket中AWS SDK的以取得 Kotlin API 的參考資料

PHP

適用於 PHP 的 SDK

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 AWS 程式碼範例儲存庫中設定和執行。

建立儲存貯體。

        $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.");
        }

• 如需詳API細資訊，請參閱AWS SDK for PHP API參考CreateBucket中的。

Python

SDK對於 Python（肉毒桿菌 3）

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 AWS 程式碼範例儲存庫中設定和執行。

使用預設設定建立儲存貯體。

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

透過生命週期組態建立版本控制儲存貯體。

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

• 如需API詳細資訊，請參閱CreateBucket中AWS SDK的〈〉中的〈〉API。

Ruby

SDK對於紅寶石

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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__

• 如需詳API細資訊，請參閱AWS SDK for Ruby API參考CreateBucket中的。

Rust

SDK對於銹

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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
}

• 如需詳API細資訊，請參閱CreateBucket中AWS SDK的以取得 Rust API 參考

SAP ABAP

SDK對於 SAP ABAP

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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.

• 如需詳API細資訊，請參閱CreateBucket中AWS SDK的以供SAPABAPAPI參考。

Swift

SDK為斯威夫特

注意

這是預覽版的售前版說明文件。SDK內容可能變動。

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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)
    }

• 有API關詳細信息，請參閱CreateBucket中AWS SDK的以獲取 Swift API 參考。

注意

您也可以使用其他帳戶的 Amazon S3 儲存貯體，但您可能需要建立適用於該儲存貯體的政策，將存取許可授予 AWS Config。如需授予 Amazon S3 儲存貯體許可的相關資訊，請參閱《適用於 AWS Config 交付通道的 Amazon S3 儲存貯體的許可》，然後前往《第 2 步：創建一個 Amazon SNS 主題》。

第 2 步：創建一個 Amazon SNS 主題

如果您的帳戶中已經有 Amazon SNS 主題並想要使用它，請跳過此步驟並轉到步驟 3：建立IAM角色。

使用控SNS制台

要創建一個 Amazon SNS 主題

1. 在 https://console.aws.amazon.com/sns/v3/ home 上打開 Amazon SNS 控制台。

2. 執行以下任意一項：

   • 如果您 AWS 帳戶 之前沒有創建任何主題，請在主頁SNS上閱讀 Amazon 的說明。

   • 如果主題已在您 AWS 帳戶 之前的下方建立，請在導覽面板上選擇「主題」。

3. 在主題頁面上，選擇建立主題。

4. 在建立主題頁面上，於詳細資訊區段中，執行以下作業：

   1. 在「類型」中，選擇主題類型 (「標準」或 FIFO)。

   2. 輸入新主題的 名稱 (Name)。對於FIFO主題，請在名稱的末尾加上 .fifo。

   3. (選用) 為主題輸入 Display name (顯示名稱)。

   4. (選擇性) 針對FIFO主題，您可以選擇以內容為基礎的郵件重複資料刪除功能，以啟用預設的重複資料刪除 如需詳細資訊，請參閱重複資料刪除FIFO主題的訊息。

5. (選用) 展開 Encryption (加密) 區段並執行下列動作。如需詳細資訊，請參閱靜態加密。

   1. 選擇 Enable encryption (啟用加密)。

   2. 指定客戶主要金鑰 (CMK)。如需詳細資訊，請參閱重要用語。

      對於每CMK種類型，都會顯示「描述」、「帳戶」和 CMKARN「帳戶」。

      重要

      如果您不是的擁有者CMK，或者使用沒有kms:ListAliases和kms:DescribeKey許可的帳戶登入，您將無法在 Amazon SNS 主控台CMK上檢視有關的資訊。

      要求的擁有者授CMK與您這些權限。如需詳細資訊，請參閱AWS Key Management Service 開發人員指南中的AWS KMS API權限：動作和資源參考。

      • 預設會選CMK取「Amazon AWS 管理 SNS (預設) 別名/aws/SNS」。

        注意

        請謹記以下幾點：

        • 當您第一次使用指 AWS Management Console 定主題CMK的 Amazon AWS SNS 受管時， AWS KMS 會CMK為 Amazon 建立 AWS 受管SNS。

        • 或者，當您第一次對SSE已啟用的主題使用Publish動作時， AWS KMS 會CMK為 Amazon 建立 AWS 受管SNS。

      • 若要使用您的CMK自訂 AWS 帳戶，請選擇「客戶主金鑰」(CMK) 欄位，然後CMK從清單中選擇自訂。

        注意

        如需建立自訂金鑰的指示CMKs，請參閱AWS Key Management Service 開發人員指南中的建立金鑰

      • 若要使用CMKARN來自您 AWS 帳戶 或其他 AWS 帳戶的自訂，請在客戶主金鑰 (CMK) 欄位中輸入該自訂金鑰。

6. (選用) 根據預設，只有主題擁有者可以發布或訂閱主題。若要設定其他存取許可，請展開 Access policy (存取政策) 區段。如需詳細資訊，請參閱 Amazon 中的身分識別和存取管理SNS和 Amazon SNS 存取控制範例案例。

   注意

   當您使用主控台建立主題時，預設政策會使用 aws:SourceOwner 條件金鑰。此金鑰類似於 aws:SourceAccount。

7. (選擇性) 若要設定 Amazon SNS 重試失敗訊息傳遞嘗試的方式，請展開傳送重試政策 (HTTP/S) 區段。如需詳細資訊，請參閱 Amazon 訊SNS息交付重試。

8. (選擇性) 若要設定 Amazon 記SNS錄訊息交付的方式 CloudWatch，請展開交付狀態記錄區段。如需詳細資訊，請參閱 Amazon 訊SNS息交付狀態。

9. (選用) 若要將中繼資料標籤新增至主題，請展開 Tags (標籤) 區段，輸入 Key(金鑰) 和 Value (值) (選用)，然後選擇 Add tag (新增標籤)。如需詳細資訊，請參閱 Amazon SNS 主題標記。

10. 請選擇建立主題。

    主題隨即建立，MyTopic顯示頁面。

    主題的名稱、ARN、(選用) [顯示名稱] 和 [主題擁有者的 AWS 帳號 ID] 會顯示在 [詳細資料] 區段中。

11. 將主題複製ARN到剪貼簿，例如：

    arn:aws:sns:us-east-2:123456789012:MyTopic

訂閱 Amazon SNS 主題的電子郵件地址

1. 在 https://console.aws.amazon.com/sns/v3/ home 上打開 Amazon SNS 控制台。

2. 在左導覽窗格中，選擇訂閱。

3. 在訂閱頁面，選擇建立訂閱。

4. 在建立訂閱頁面上，於詳細資訊區段中，執行以下作業：

   1. 對於「主題」ARN，請選擇主題的 Amazon 資源名稱 (ARN)。

   2. 在 Protocol (通訊協定)，選擇端點類型。可用的端點類型為：

      • HTTP/HTTPS

      • 電郵/電郵-JSON

      • Amazon 數據 Firehose

      • Amazon SQS

        注意

        若要訂閱SNSFIFO主題，請選擇此選項。

      • AWS Lambda

      • 平台應用程式端點

      • SMS

   3. 對於端點，請輸入端點值，例如電子郵件地址或 Amazon SQS 佇列ARN的值。

   4. 僅限 Firehose 端點：對於訂閱角色 ARN，請指定您為寫入 Firehose 傳遞串流而建立ARN的IAM角色。如需詳細資訊，請參閱訂閱 Firehose 交付串流至 Amazon SNS 的先決條件主題。

   5. (選擇性) 對於 Firehose、Amazon SQS、HTTP /S 端點，您也可以啟用原始訊息傳遞。如需詳細資訊，請參閱 Amazon SNS 原始訊息交付。

   6. (選用) 若要設定篩選政策，請展開 Subscription filter policy (訂閱篩選政策) 區段。如需詳細資訊，請參閱 Amazon SNS 訂閱篩選器政策。

   7. (選用) 若要設定訂閱的無效字母佇列，請展開 Redrive policy (dead-letter queue) (重新磁碟機政策 (無效字母佇列)) 區段。如需詳細資訊，請參閱 Amazon SNS 無效字母佇列 () DLQs。

   8. 選擇 Create subscription (建立訂閱)。

      主控台會建立訂閱並開啟訂閱的 Details (詳細資訊) 頁面

使用 AWS SDKs

若要使用 AWS SDK，您必須使用您的認證進行設定。如需詳細資訊，請參閱《工具參考指南》中的共用設定AWS SDKs和認證檔案。

下列程式碼範例會示範如何使用CreateTopic。

.NET

AWS SDK for .NET

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 AWS 程式碼範例儲存庫中設定和執行。

建立具有特定名稱的主題。

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

使用名稱和特定FIFO和重複資料刪除屬性建立新主題。

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

• 如需詳API細資訊，請參閱AWS SDK for .NET API參考CreateTopic中的。

C++

SDK對於 C ++

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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();
}

• 如需詳API細資訊，請參閱AWS SDK for C++ API參考CreateTopic中的。

CLI

AWS CLI

建立 SNS 主題

下列create-topic範例會建立名為的SNS主題my-topic。

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

輸出：

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

如需詳細資訊，請參閱命 AWS 令列介面使用者指南SNS中的 Amazon SQS 和 Amazon 使用AWS 命令列界面。

• 如需詳API細資訊，請參閱AWS CLI 指令參考CreateTopic中的。

Go

SDK對於轉到 V2

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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
}

• 如需詳API細資訊，請參閱AWS SDK for Go API參考CreateTopic中的。

Java

SDK對於爪哇 2.x

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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 "";
    }
}

• 如需詳API細資訊，請參閱AWS SDK for Java 2.x API參考CreateTopic中的。

JavaScript

SDK對於 JavaScript （3）

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 AWS 程式碼範例儲存庫中設定和執行。

在單獨的模組中建立用戶端並將其匯出。

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

匯入SDK和用戶端模組並呼叫API.

import { CreateTopicCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicName - The name of the topic to create.
 */
export const createTopic = async (topicName = "TOPIC_NAME") => {
  const response = await snsClient.send(
    new CreateTopicCommand({ Name: topicName }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '087b8ad2-4593-50c4-a496-d7e90b82cf3e',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   TopicArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:TOPIC_NAME'
  // }
  return response;
};

• 如需詳細資訊，請參閱《AWS SDK for JavaScript 開發人員指南》。

• 如需詳API細資訊，請參閱AWS SDK for JavaScript API參考CreateTopic中的。

Kotlin

SDK對於科特林

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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()
    }
}

• 有API關詳細資訊，請參閱CreateTopic中AWS SDK的以取得 Kotlin API 的參考資料

PHP

適用於 PHP 的 SDK

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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());
}

• 如需詳細資訊，請參閱《AWS SDK for PHP 開發人員指南》。

• 如需詳API細資訊，請參閱AWS SDK for PHP API參考CreateTopic中的。

Python

SDK對於 Python（肉毒桿菌 3）

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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

• 如需API詳細資訊，請參閱CreateTopic中AWS SDK的〈〉中的〈〉API。

Ruby

SDK對於紅寶石

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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

• 如需詳細資訊，請參閱《AWS SDK for Ruby 開發人員指南》。

• 如需詳API細資訊，請參閱AWS SDK for Ruby API參考CreateTopic中的。

Rust

SDK對於銹

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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(())
}

• 如需詳API細資訊，請參閱CreateTopic中AWS SDK的以取得 Rust API 參考

SAP ABAP

SDK對於 SAP ABAP

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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.

• 如需詳API細資訊，請參閱CreateTopic中AWS SDK的以供SAPABAPAPI參考。

注意

您也可以在不同的帳戶中使用 Amazon SNS 主題，但在這種情況下，您可能需要為授予存取權限的主題建立政策 AWS Config。如需授予 Amazon SNS 主題許可的相關資訊，請參閱，Amazon SNS 主題的許可然後移至步驟 3：建立IAM角色。

步驟 3：建立IAM角色

使用控IAM制台

您可以使用主IAM控台建立IAM角色，以 AWS Config 授與存取 Amazon S3 儲存貯體、存取 Amazon SNS 主題，以及取得支援 AWS 資源的組態詳細資訊。當您使用主控台建立IAM角色時， AWS Config 會自動為您附加必要的權限至該角色。

注意

如果您使用的 AWS 服務使用 AWS Config (例如 AWS Security Hub 或 AWS Control Tower)，且已建立 AWS Config 角色，則應確定您在設定時使用的IAM角色與已建立的角 AWS Config 色 AWS Config 保持相同的最低權限，以便其他 AWS 服務如預期般繼續執行。

例如，如果 AWS Control Tower 具有允許讀 AWS Config 取 Amazon S3 物件的IAM角色，則應確保在設定時所使用的IAM角色中授予相同的許可 AWS Config。否則，可能會干擾 AWS 控制塔的運作。

如需有關IAM角色的詳細資訊 AWS Config，請參閱 AWS Identity and Access Management。

若要建立 AWS 服務的角色

1. 登入 AWS Management Console 並開啟IAM主控台，位於https://console.aws.amazon.com/iam/。

2. 在IAM主控台的導覽窗格中，選擇 [角色]，然後選擇 [建立角色]。

3. 對於 Select trusted entity (選取信任的實體) 區段，選擇 AWS service (AWS 服務)。

4. 選擇您想要的使用案例 AWS Config：「組 Config-自訂」、「組 Config- Organizations」、「組 Config」或「組 Config-一致性套件」。然後選擇下一步。

5. 在 名稱、檢閱和建立 頁面中，檢閱角色的詳細資訊，然後選擇 建立角色。

使用 AWS SDKs

若要使用 AWS SDK，您必須使用您的認證進行設定。如需詳細資訊，請參閱《工具參考指南》中的共用設定AWS SDKs和認證檔案。

下列程式碼範例會示範如何使用CreateRole。

.NET

AWS SDK for .NET

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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;
    }

• 如需詳API細資訊，請參閱AWS SDK for .NET API參考CreateRole中的。

Bash

AWS CLI 使用 Bash 腳本

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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
}

• 如需詳API細資訊，請參閱AWS CLI 指令參考CreateRole中的。

C++

SDK對於 C ++

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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();
}

• 如需詳API細資訊，請參閱AWS SDK for C++ API參考CreateRole中的。

CLI

AWS CLI

範例 1：建立IAM角色

下列 create-role 命令會建立名為 Test-Role 的角色，並將信任政策連接至該角色。

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

輸出：

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

信任原則定義為測試角色信任 Policy.json JSON 檔案中的文件。(檔案名稱和副檔名沒有意義。) 信任政策必須指定主體。

若要將許可政策連接至角色，請使用 put-role-policy 命令。

如需詳細資訊，請參閱《使用指南》中的AWS IAM〈建立IAM角色〉。

範例 2：建立具有指定工作階段持續時間上限的IAM角色

下列 create-role 命令會建立名為 Test-Role 的角色，並設定 7200 秒 (2 小時) 的最長工作階段持續時間。

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

輸出：

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

如需詳細資訊，請參閱《AWS IAM使用者指南》中的修改角色工作階段持續時間上限 (AWS API)。

範例 3：若要建立含標籤的IAM角色

下面的命令創建一個Test-Role帶有標籤的IAM角色。此範例使用具有下列JSON格式化標記的--tags參數旗標：'{"Key": "Department", "Value": "Accounting"}' '{"Key": "Location", "Value": "Seattle"}'。或者，--tags 旗標可以與速記格式的標籤一起使用：'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"}'

輸出：

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

如需詳細資訊，請參閱《使用指南》中的AWS IAM〈標記IAM角色〉。

• 如需詳API細資訊，請參閱AWS CLI 指令參考CreateRole中的。

Go

SDK對於轉到 V2

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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
}

• 如需詳API細資訊，請參閱AWS SDK for Go API參考CreateRole中的。

Java

SDK對於爪哇 2.x

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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);
    }
}

• 如需詳API細資訊，請參閱AWS SDK for Java 2.x API參考CreateRole中的。

JavaScript

SDK對於 JavaScript （3）

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 AWS 程式碼範例儲存庫中設定和執行。

建立角色。

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

• 如需詳API細資訊，請參閱AWS SDK for JavaScript API參考CreateRole中的。

PHP

適用於 PHP 的 SDK

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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'];
    }

• 如需詳API細資訊，請參閱AWS SDK for PHP API參考CreateRole中的。

PowerShell

用於的工具 PowerShell

範例 1：此範例會建立名為的新角色，MyNewRole並附加檔案中找到的策略NewRoleTrustPolicy.json。請注意，您必須使用 -Raw switch 參數才能成功處理JSON原則檔。輸出中顯示的策略文件會URL進行編碼。它是在這個例子中解碼與. UrlDecode NET方法。

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

輸出：

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

• 如需詳API細資訊，請參閱AWS Tools for PowerShell 指令程CreateRole式參考中的。

Python

SDK對於 Python（肉毒桿菌 3）

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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

• 如需API詳細資訊，請參閱CreateRole中AWS SDK的〈〉中的〈〉API。

Ruby

SDK對於紅寶石

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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

• 如需詳API細資訊，請參閱AWS SDK for Ruby API參考CreateRole中的。

Rust

SDK對於銹

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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())
}

• 如需詳API細資訊，請參閱CreateRole中AWS SDK的以取得 Rust API 參考

Swift

SDK為斯威夫特

注意

這是預覽版的售前版說明文件。SDK內容可能變動。

注意

還有更多關於 GitHub。尋找完整範例，並了解如何在 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
        }
    }

• 有API關詳細信息，請參閱CreateRole中AWS SDK的以獲取 Swift API 參考。