翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# SDK for Kotlin を使用して Amazon S3 マルチリージョンアクセスポイントを操作する
<a name="use-services-s3-mrap"></a>

Amazon S3 マルチリージョンアクセスポイントを使用すると、アプリケーションが複数の AWS リージョンにあるAmazon S3 バケットからのリクエストを実行するために使用できるグローバルエンドポイントを作成できます。マルチリージョンアクセスポイントを使用して、単一のリージョンで使用されるのと同じアーキテクチャでマルチリージョンアプリケーションを構築し、世界中のどこでもこれらのアプリケーションを実行することができます。

Amazon S3 ユーザーガイドには[、マルチリージョンアクセスポイント](https://docs.aws.amazon.com//AmazonS3/latest/userguide/MultiRegionAccessPoints.html)に関する詳細な背景情報が含まれています。

## マルチリージョンアクセスポイントの使用
<a name="mrap-s3control-config"></a>

マルチリージョンアクセスポイントを作成するには、まず、リクエストを処理する AWS リージョンごとに 1 つのバケットを指定します。次のスニペットでは、2 つのバケットを作成します。

### バケットを作成する
<a name="mrap-s3-create-buckets"></a>

次の 関数は、マルチリージョンアクセスポイントを操作する 2 つのバケットを作成します。1 つのバケットはリージョン にあり`us-east-1`、もう 1 つのバケットはリージョン にあります`us-west-1`。

最初の引数として に渡された S3 クライアントの作成は、 の最初の例に示されています[オブジェクトとマルチリージョンアクセスポイントの操作](#mrap-s3client-config)。

```
        suspend fun setUpTwoBuckets(
            s3: S3Client,
            bucketName1: String,
            bucketName2: String,
        ) {
            println("Create two buckets in different regions.")
            // The shared aws config file configures the default Region to be us-east-1.
            s3.createBucket(
                CreateBucketRequest {
                    bucket = bucketName1
                },
            )
            s3.waitUntilBucketExists {
                bucket = bucketName1
            }
            println("  Bucket [$bucketName1] created.")

            // Override the S3Client to work with us-west-1 for the second bucket.
            s3.withConfig {
                region = "us-west-1"
            }.use { s3West ->
                s3West.createBucket(
                    CreateBucketRequest {
                        bucket = bucketName2
                        createBucketConfiguration = CreateBucketConfiguration {
                            locationConstraint = BucketLocationConstraint.UsWest1
                        }
                    },
                )
                s3West.waitUntilBucketExists {
                    bucket = bucketName2
                }
                println("  Bucket [$bucketName2] created.")
            }
        }
```

Kotlin SDK の [S3 コントロールクライアント](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/s3control/aws.sdk.kotlin.services.s3control/-s3-control-client/index.html)を使用して、マルチリージョンアクセスポイントに関する情報を作成、削除、取得します。

次のスニペットに示すように、S3 コントロールアーティファクトへの依存関係を追加します。(*X.Y.Z* リンクに移動して、利用可能な最新バージョンを確認できます）。

```
...
implementation(platform("aws.sdk.kotlin:bom:[https://github.com/awslabs/aws-sdk-kotlin/releases/latest](https://github.com/awslabs/aws-sdk-kotlin/releases/latest)"))
implementation("aws.sdk.kotlin:s3control")
...
```

次のコードに示すように、 を使用する AWS リージョン `us-west-2`ように S3 コントロールクライアントを設定します。すべての S3 コントロールクライアントオペレーションは`us-west-2`、リージョンをターゲットにする必要があります。

```
        suspend fun createS3ControlClient(): S3ControlClient {
            // Configure your S3ControlClient to send requests to US West (Oregon).
            val s3Control = S3ControlClient.fromEnvironment {
                region = "us-west-2"
            }
            return s3Control
        }
```

次のコードに示すように、S3 コントロールクライアントを使用して、バケット名 (以前に作成したもの) を指定してマルチリージョンアクセスポイントを作成します。

```
    suspend fun createMrap(
        s3Control: S3ControlClient,
        accountIdParam: String,
        bucketName1: String,
        bucketName2: String,
        mrapName: String,
    ): String {
        println("Creating MRAP ...")
        val createMrapResponse: CreateMultiRegionAccessPointResponse =
            s3Control.createMultiRegionAccessPoint {
                accountId = accountIdParam
                clientToken = UUID.randomUUID().toString()
                details {
                    name = mrapName
                    regions = listOf(
                        Region {
                            bucket = bucketName1
                        },
                        Region {
                            bucket = bucketName2
                        },
                    )
                }
            }
        val requestToken: String? = createMrapResponse.requestTokenArn

        // Use the request token to check for the status of the CreateMultiRegionAccessPoint operation.
        if (requestToken != null) {
            waitForSucceededStatus(s3Control, requestToken, accountIdParam)
            println("MRAP created")
        }

        val getMrapResponse =
            s3Control.getMultiRegionAccessPoint(
                input = GetMultiRegionAccessPointRequest {
                    accountId = accountIdParam
                    name = mrapName
                },
            )
        val mrapAlias = getMrapResponse.accessPoint?.alias
        return "arn:aws:s3::$accountIdParam:accesspoint/$mrapAlias"
    }
```

マルチリージョンアクセスポイントの作成は非同期オペレーションであるため、即時レスポンスから受け取ったトークンを使用して作成プロセスのステータスを確認します。ステータスチェックが成功メッセージを返した後、 `GetMultiRegionAccessPoint`オペレーションを使用してマルチリージョンアクセスポイントのエイリアスを取得できます。エイリアスは、オブジェクトレベルのオペレーションに必要な ARN の最後のコンポーネントです。

### トークンを使用してステータスを確認する
<a name="mrap-s3-control-poll"></a>

を使用して、最後のオペレーションのステータス`DescribeMultiRegionAccessPointOperation`を確認します。`requestStatus` 値が「SUCCEEDED」になったら、マルチリージョンアクセスポイントを使用できます。

```
        suspend fun waitForSucceededStatus(
            s3Control: S3ControlClient,
            requestToken: String,
            accountIdParam: String,
            timeBetweenChecks: Duration = 1.minutes,
        ) {
            var describeResponse: DescribeMultiRegionAccessPointOperationResponse
            describeResponse = s3Control.describeMultiRegionAccessPointOperation(
                input = DescribeMultiRegionAccessPointOperationRequest {
                    accountId = accountIdParam
                    requestTokenArn = requestToken
                },
            )

            var status: String? = describeResponse.asyncOperation?.requestStatus
            while (status != "SUCCEEDED") {
                delay(timeBetweenChecks)
                describeResponse = s3Control.describeMultiRegionAccessPointOperation(
                    input = DescribeMultiRegionAccessPointOperationRequest {
                        accountId = accountIdParam
                        requestTokenArn = requestToken
                    },
                )
                status = describeResponse.asyncOperation?.requestStatus
                println(status)
            }
        }
```

## オブジェクトとマルチリージョンアクセスポイントの操作
<a name="mrap-s3client-config"></a>

[S3 クライアント](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/s3/aws.sdk.kotlin.services.s3/-s3-client/index.html)を使用して、マルチリージョンアクセスポイントのオブジェクトを操作します。マルチリージョンアクセスポイントで使用できるバケット内のオブジェクトで使用するオペレーションの多くは、次のとおりです。オペレーションの詳細と詳細なリストについては、[「マルチリージョンアクセスポイントと S3 オペレーションとの互換性](https://docs.aws.amazon.com//AmazonS3/latest/userguide/MrapOperations.html#mrap-operations-support)」を参照してください。

マルチリージョンアクセスポイントを使用するオペレーションは、非対称 SigV4 (SigV4a) 署名アルゴリズムで署名されます。SigV4a を設定するには、まず次の依存関係をプロジェクトに追加します。(*X.Y.Z* リンクに移動して、利用可能な最新バージョンを確認できます）。

```
...
implementation(platform("aws.sdk.kotlin:bom:[https://github.com/awslabs/aws-sdk-kotlin/releases/latest](https://github.com/awslabs/aws-sdk-kotlin/releases/latest)"))
implementation(platform("aws.smithy.kotlin:bom:[https://github.com/smithy-lang/smithy-kotlin/releases/latest](https://github.com/smithy-lang/smithy-kotlin/releases/latest)"))

implementation("aws.smithy.kotlin:aws-signing-default")
implementation("aws.smithy.kotlin:http-auth-aws")
implementation("aws.sdk.kotlin:s3")
...
```

依存関係を追加したら、次のコードに示すように SigV4a 署名アルゴリズムを使用するように S3 クライアントを設定します。

```
        suspend fun createS3Client(): S3Client {
            // Configure your S3Client to use the Asymmetric SigV4 (SigV4a) signing algorithm.
            val sigV4aScheme = SigV4AsymmetricAuthScheme(DefaultAwsSigner)
            val s3 = S3Client.fromEnvironment {
                authSchemes = listOf(sigV4aScheme)
            }
            return s3
        }
```

S3 クライアントを設定すると、S3 がマルチリージョンアクセスポイントでサポートするオペレーションは同じように機能します。唯一の違いは、バケットパラメータがマルチリージョンアクセスポイントの ARN であることです。ARN を返す`createMrap`関数で前述したように、Amazon S3 コンソールから、またはプログラムで ARN を取得できます。

次のコード例は、`GetObject`オペレーションで使用される ARN を示しています。

```
    suspend fun getObjectFromMrap(
        s3: S3Client,
        mrapArn: String,
        keyName: String,
    ): String? {
        val request = GetObjectRequest {
            bucket = mrapArn // Use the ARN instead of the bucket name for object operations.
            key = keyName
        }

        var stringObj: String? = null
        s3.getObject(request) { resp ->
            stringObj = resp.body?.decodeToString()
            if (stringObj != null) {
                println("Successfully read $keyName from $mrapArn")
            }
        }
        return stringObj
    }
```