

# S3 on Outposts 객체 작업
<a name="S3OutpostsWorkingObjects"></a>

Amazon S3 on Outposts를 사용하면 AWS Outposts에서 S3 버킷을 생성하고 로컬 데이터 액세스, 로컬 데이터 처리 및 데이터 레지던시가 필요한 애플리케이션을 위해 온프레미스에서 객체를 쉽게 저장하고 검색할 수 있습니다. S3 on Outposts는 S3 Outposts(`OUTPOSTS`)라는 새로운 스토리지 클래스를 제공합니다. 이 클래스는 Amazon S3 API를 사용하며 AWS Outposts의 여러 디바이스와 서버에 데이터를 이중화된 방식으로 안정적으로 저장하도록 설계되었습니다. Virtual Private Cloud(VPC)를 통한 액세스 포인트 및 엔드포인트 연결을 사용하여 Outpost 버킷과 통신합니다. 액세스 정책, 암호화, 태깅을 포함하여 Amazon S3 버킷에서와 같이 Outpost 버킷에서 동일한 API 및 기능을 사용할 수 있습니다. AWS Management Console, AWS Command Line Interface(AWS CLI), AWS SDK 또는 REST API를 통해 S3 on Outposts를 사용할 수 있습니다.

객체는 Amazon S3 on Outposts에 저장되는 기본 개체입니다. 모든 객체는 어떤 버킷에 포함됩니다. Outpost 버킷의 객체에 액세스하려면 액세스 포인트를 사용해야 합니다. 객체 작업에 버킷을 지정할 때 액세스 포인트 이름이 포함된 액세스 포인트 Amazon 리소스 이름(ARN) 또는 액세스 포인트 별칭을 사용합니다. 액세스 포인트 별칭에 대한 자세한 내용은 [S3 on Outposts 버킷 액세스 포인트에 버킷 스타일 별칭 사용](s3-outposts-access-points-alias.md) 섹션을 참조하세요.

다음 예제는 S3 on Outposts 액세스 포인트에 대한 ARN 형식을 보여줍니다. 여기에는 Outpost가 있는 리전의 AWS 리전 코드, AWS 계정 ID, Outpost ID 및 액세스 포인트 이름이 포함됩니다.

```
arn:aws:s3-outposts:region:account-id:outpost/outpost-id/accesspoint/accesspoint-name
```

S3 on Outposts ARN에 대한 자세한 내용은 [S3 on Outposts의 리소스 ARN](S3OutpostsIAM.md#S3OutpostsARN) 단원을 참조하세요.

객체 ARN은 Outpost가 위치한 AWS 리전, AWS 계정 ID, Outpost ID, 버킷 이름, 객체 키를 포함한 다음과 같은 형식을 사용합니다.

```
arn:aws:s3-outposts:us-west-2:123456789012:​outpost/op-01ac5d28a6a232904/bucket/amzn-s3-demo-bucket1/object/myobject
```

Amazon S3 on Outposts를 사용할 경우 객체 데이터는 항상 Outpost에 저장됩니다. AWS가 Outpost 랙을 설치하는 경우 데이터 상주 요구 사항을 충족하기 위해 데이터가 Outpost에 로컬로 유지됩니다. 객체는 Outpost에서 벗어나지 않으며 AWS 리전에 있지 않습니다. AWS Management Console이 리전 내에 호스팅되므로 콘솔을 사용하여 Outpost의 객체를 업로드하거나 관리할 수 없습니다. 그러나 REST API, AWS Command Line Interface(AWS CLI), AWS SDK를 사용하여 액세스 포인트를 통해 객체를 업로드하고 관리할 수 있습니다.

**Topics**
+ [S3 on Outposts 버킷에 객체 업로드](S3OutpostsUploadObjects.md)
+ [AWS SDK for Java를 사용하여 Amazon S3 on Outposts 버킷의 객체 복사](S3OutpostsCopyObject.md)
+ [Amazon S3 on Outposts 버킷에서 객체 가져오기](S3OutpostsGetObject.md)
+ [Amazon S3 on Outposts 버킷의 객체 나열](S3OutpostsListObjects.md)
+ [Amazon S3 on Outposts 버킷의 객체 삭제](S3OutpostsDeleteObject.md)
+ [HeadBucket을 사용하여 S3 on Outposts 버킷이 존재하고 버킷에 액세스할 수 있는 권한이 있는지 확인](S3OutpostsHeadBucket.md)
+ [Java용 SDK를 사용하여 멀티파트 업로드 수행 및 관리](S3OutpostsMPU.md)
+ [S3 on Outposts에서 미리 서명된 URL 사용](S3OutpostsPresignedURL.md)
+ [로컬 Amazon EMR on Outposts를 사용하는 Amazon S3 on Outposts](s3-outposts-emr.md)
+ [권한 부여 및 인증 캐시](s3-outposts-auth-cache.md)

# S3 on Outposts 버킷에 객체 업로드
<a name="S3OutpostsUploadObjects"></a>

객체는 Amazon S3 on Outposts에 저장되는 기본 개체입니다. 모든 객체는 어떤 버킷에 포함됩니다. Outpost 버킷의 객체에 액세스하려면 액세스 포인트를 사용해야 합니다. 객체 작업에 버킷을 지정할 때 액세스 포인트 이름이 포함된 액세스 포인트 Amazon 리소스 이름(ARN) 또는 액세스 포인트 별칭을 사용합니다. 액세스 포인트 별칭에 대한 자세한 내용은 [S3 on Outposts 버킷 액세스 포인트에 버킷 스타일 별칭 사용](s3-outposts-access-points-alias.md) 섹션을 참조하세요.

다음 예제는 S3 on Outposts 액세스 포인트에 대한 ARN 형식을 보여줍니다. 여기에는 Outpost가 있는 리전의 AWS 리전 코드, AWS 계정 ID, Outpost ID 및 액세스 포인트 이름이 포함됩니다.

```
arn:aws:s3-outposts:region:account-id:outpost/outpost-id/accesspoint/accesspoint-name
```

S3 on Outposts ARN에 대한 자세한 내용은 [S3 on Outposts의 리소스 ARN](S3OutpostsIAM.md#S3OutpostsARN) 단원을 참조하세요.

Amazon S3 on Outposts를 사용할 경우 객체 데이터는 항상 Outpost에 저장됩니다. AWS가 Outpost 랙을 설치하는 경우 데이터 상주 요구 사항을 충족하기 위해 데이터가 Outpost에 로컬로 유지됩니다. 객체는 Outpost에서 벗어나지 않으며 AWS 리전에 있지 않습니다. AWS Management Console이 리전 내에 호스팅되므로 콘솔을 사용하여 Outpost의 객체를 업로드하거나 관리할 수 없습니다. 그러나 REST API, AWS Command Line Interface(AWS CLI), AWS SDK를 사용하여 액세스 포인트를 통해 객체를 업로드하고 관리할 수 있습니다.

다음 AWS CLI 및 AWS SDK for Java 예제에서는 액세스 포인트를 사용하여 S3 on Outposts 버킷에 객체를 업로드하는 방법을 보여줍니다.

------
#### [ AWS CLI ]

**Example**  
다음 예제에서는 AWS CLI를 사용하여 `sample-object.xml`이라는 객체를 S3 on Outposts 버킷(`s3-outposts:PutObject`)에 배치합니다. 이 명령을 사용하려면 각 `user input placeholder`를 사용자의 정보로 대체합니다. 이 명령에 대한 자세한 내용은 *AWS CLI 참조*의 [put-object](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-object.html)를 참조하세요.  

```
aws s3api put-object --bucket arn:aws:s3-outposts:Region:123456789012:outpost/op-01ac5d28a6a232904/accesspoint/example-outposts-access-point --key sample-object.xml --body sample-object.xml
```

------
#### [ SDK for Java ]

**Example**  
AWS SDK를 사용하여 S3 Outposts 버킷에 객체를 업로드하는 방법의 예는 *AWS SDK for Java 2.x 코드 예제*의 [PutObjectOnOutpost.java](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/s3/src/main/java/com/example/s3/outposts/PutObjectOnOutpost.java)를 참조하세요.

------

# AWS SDK for Java를 사용하여 Amazon S3 on Outposts 버킷의 객체 복사
<a name="S3OutpostsCopyObject"></a>

객체는 Amazon S3 on Outposts에 저장되는 기본 개체입니다. 모든 객체는 어떤 버킷에 포함됩니다. Outpost 버킷의 객체에 액세스하려면 액세스 포인트를 사용해야 합니다. 객체 작업에 버킷을 지정할 때 액세스 포인트 이름이 포함된 액세스 포인트 Amazon 리소스 이름(ARN) 또는 액세스 포인트 별칭을 사용합니다. 액세스 포인트 별칭에 대한 자세한 내용은 [S3 on Outposts 버킷 액세스 포인트에 버킷 스타일 별칭 사용](s3-outposts-access-points-alias.md) 섹션을 참조하세요.

다음 예제는 S3 on Outposts 액세스 포인트에 대한 ARN 형식을 보여줍니다. 여기에는 Outpost가 있는 리전의 AWS 리전 코드, AWS 계정 ID, Outpost ID 및 액세스 포인트 이름이 포함됩니다.

```
arn:aws:s3-outposts:region:account-id:outpost/outpost-id/accesspoint/accesspoint-name
```

S3 on Outposts ARN에 대한 자세한 내용은 [S3 on Outposts의 리소스 ARN](S3OutpostsIAM.md#S3OutpostsARN) 단원을 참조하세요.

Amazon S3 on Outposts를 사용할 경우 객체 데이터는 항상 Outpost에 저장됩니다. AWS가 Outpost 랙을 설치하는 경우 데이터 상주 요구 사항을 충족하기 위해 데이터가 Outpost에 로컬로 유지됩니다. 객체는 Outpost에서 벗어나지 않으며 AWS 리전에 있지 않습니다. AWS Management Console이 리전 내에 호스팅되므로 콘솔을 사용하여 Outpost의 객체를 업로드하거나 관리할 수 없습니다. 그러나 REST API, AWS Command Line Interface(AWS CLI), AWS SDK를 사용하여 액세스 포인트를 통해 객체를 업로드하고 관리할 수 있습니다.

다음 예제에서는 AWS SDK for Java를 사용하여 S3 on Outposts 버킷의 객체를 나열하는 방법을 보여줍니다.

## Java용 AWS SDK 사용
<a name="S3OutpostsCopyObjectJava"></a>

다음 S3 on Outposts 예제에서는 SDK for Java를 사용하여 객체를 동일한 버킷의 새 객체로 복사합니다. 이 예제를 사용하려면 `user input placeholders`를 사용자의 정보로 대체합니다.

```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.CopyObjectRequest;

public class CopyObject {
    public static void main(String[] args) {
        String accessPointArn = "*** access point ARN ***";
        String sourceKey = "*** Source object key ***";
        String destinationKey = "*** Destination object key ***";

        try {
            // This code expects that you have AWS credentials set up per:
            // https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .enableUseArnRegion()
                    .build();

            // Copy the object into a new object in the same bucket.
            CopyObjectRequest copyObjectRequest = new CopyObjectRequest(accessPointArn, sourceKey, accessPointArn, destinationKey);
            s3Client.copyObject(copyObjectRequest);
        } catch (AmazonServiceException e) {
            // The call was transmitted successfully, but Amazon S3 couldn't process
            // it, so it returned an error response.
            e.printStackTrace();
        } catch (SdkClientException e) {
            // Amazon S3 couldn't be contacted for a response, or the client
            // couldn't parse the response from Amazon S3.
            e.printStackTrace();
        }
    }
}
```

# Amazon S3 on Outposts 버킷에서 객체 가져오기
<a name="S3OutpostsGetObject"></a>

객체는 Amazon S3 on Outposts에 저장되는 기본 개체입니다. 모든 객체는 어떤 버킷에 포함됩니다. Outpost 버킷의 객체에 액세스하려면 액세스 포인트를 사용해야 합니다. 객체 작업에 버킷을 지정할 때 액세스 포인트 이름이 포함된 액세스 포인트 Amazon 리소스 이름(ARN) 또는 액세스 포인트 별칭을 사용합니다. 액세스 포인트 별칭에 대한 자세한 내용은 [S3 on Outposts 버킷 액세스 포인트에 버킷 스타일 별칭 사용](s3-outposts-access-points-alias.md) 섹션을 참조하세요.

다음 예제는 S3 on Outposts 액세스 포인트에 대한 ARN 형식을 보여줍니다. 여기에는 Outpost가 있는 리전의 AWS 리전 코드, AWS 계정 ID, Outpost ID 및 액세스 포인트 이름이 포함됩니다.

```
arn:aws:s3-outposts:region:account-id:outpost/outpost-id/accesspoint/accesspoint-name
```

S3 on Outposts ARN에 대한 자세한 내용은 [S3 on Outposts의 리소스 ARN](S3OutpostsIAM.md#S3OutpostsARN) 단원을 참조하세요.

Amazon S3 on Outposts를 사용할 경우 객체 데이터는 항상 Outpost에 저장됩니다. AWS가 Outpost 랙을 설치하는 경우 데이터 상주 요구 사항을 충족하기 위해 데이터가 Outpost에 로컬로 유지됩니다. 객체는 Outpost에서 벗어나지 않으며 AWS 리전에 있지 않습니다. AWS Management Console이 리전 내에 호스팅되므로 콘솔을 사용하여 Outpost의 객체를 업로드하거나 관리할 수 없습니다. 그러나 REST API, AWS Command Line Interface(AWS CLI), AWS SDK를 사용하여 액세스 포인트를 통해 객체를 업로드하고 관리할 수 있습니다.

다음 예제에서는 AWS Command Line Interface(AWS CLI) 및 AWS SDK for Java를 사용하여 객체를 다운로드(가져오기)하는 방법을 보여줍니다.

## AWS CLI 사용
<a name="S3OutpostsGetObjectCLI"></a>

다음 예제에서는 AWS CLI를 사용하여 `sample-object.xml`이라는 객체를 S3 on Outposts 버킷(`s3-outposts:GetObject`)에서 가져옵니다. 이 명령을 사용하려면 각 `user input placeholder`를 사용자의 정보로 대체합니다. 이 명령에 대한 자세한 내용은 [AWS CLI 참조](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/get-object.html)의 *get-object*를 참조하세요.

```
aws s3api get-object --bucket arn:aws:s3-outposts:region:123456789012:outpost/op-01ac5d28a6a232904/accesspoint/example-outposts-access-point --key testkey sample-object.xml
```

## Java용 AWS SDK 사용
<a name="S3OutpostsGetObjectJava"></a>

다음 S3 on Outposts 예제에서는 Java용 SDK를 사용하여 객체를 가져옵니다. 이 예제를 사용하려면 각 `user input placeholder`를 사용자의 정보로 대체합니다. 자세한 내용은 *Amazon Simple Storage Service API Reference*의 [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html) 섹션을 참조하세요.

```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.GetObjectRequest;
import com.amazonaws.services.s3.model.ResponseHeaderOverrides;
import com.amazonaws.services.s3.model.S3Object;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class GetObject {
    public static void main(String[] args) throws IOException {
        String accessPointArn = "*** access point ARN ***";
        String key = "*** Object key ***";

        S3Object fullObject = null, objectPortion = null, headerOverrideObject = null;
        try {
            // This code expects that you have AWS credentials set up per:
            // https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .enableUseArnRegion()
                    .build();

            // Get an object and print its contents.
            System.out.println("Downloading an object");
            fullObject = s3Client.getObject(new GetObjectRequest(accessPointArn, key));
            System.out.println("Content-Type: " + fullObject.getObjectMetadata().getContentType());
            System.out.println("Content: ");
            displayTextInputStream(fullObject.getObjectContent());

            // Get a range of bytes from an object and print the bytes.
            GetObjectRequest rangeObjectRequest = new GetObjectRequest(accessPointArn, key)
                    .withRange(0, 9);
            objectPortion = s3Client.getObject(rangeObjectRequest);
            System.out.println("Printing bytes retrieved.");
            displayTextInputStream(objectPortion.getObjectContent());

            // Get an entire object, overriding the specified response headers, and print the object's content.
            ResponseHeaderOverrides headerOverrides = new ResponseHeaderOverrides()
                    .withCacheControl("No-cache")
                    .withContentDisposition("attachment; filename=example.txt");
            GetObjectRequest getObjectRequestHeaderOverride = new GetObjectRequest(accessPointArn, key)
                    .withResponseHeaders(headerOverrides);
            headerOverrideObject = s3Client.getObject(getObjectRequestHeaderOverride);
            displayTextInputStream(headerOverrideObject.getObjectContent());
        } catch (AmazonServiceException e) {
            // The call was transmitted successfully, but Amazon S3 couldn't process
            // it, so it returned an error response.
            e.printStackTrace();
        } catch (SdkClientException e) {
            // Amazon S3 couldn't be contacted for a response, or the client
            // couldn't parse the response from Amazon S3.
            e.printStackTrace();
        } finally {
            // To ensure that the network connection doesn't remain open, close any open input streams.
            if (fullObject != null) {
                fullObject.close();
            }
            if (objectPortion != null) {
                objectPortion.close();
            }
            if (headerOverrideObject != null) {
                headerOverrideObject.close();
            }
        }
    }

    private static void displayTextInputStream(InputStream input) throws IOException {
        // Read the text input stream one line at a time and display each line.
        BufferedReader reader = new BufferedReader(new InputStreamReader(input));
        String line = null;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
        System.out.println();
    }
}
```

# Amazon S3 on Outposts 버킷의 객체 나열
<a name="S3OutpostsListObjects"></a>

객체는 Amazon S3 on Outposts에 저장되는 기본 개체입니다. 모든 객체는 어떤 버킷에 포함됩니다. Outpost 버킷의 객체에 액세스하려면 액세스 포인트를 사용해야 합니다. 객체 작업에 버킷을 지정할 때 액세스 포인트 이름이 포함된 액세스 포인트 Amazon 리소스 이름(ARN) 또는 액세스 포인트 별칭을 사용합니다. 액세스 포인트 별칭에 대한 자세한 내용은 [S3 on Outposts 버킷 액세스 포인트에 버킷 스타일 별칭 사용](s3-outposts-access-points-alias.md) 섹션을 참조하세요.

다음 예제는 S3 on Outposts 액세스 포인트에 대한 ARN 형식을 보여줍니다. 여기에는 Outpost가 있는 리전의 AWS 리전 코드, AWS 계정 ID, Outpost ID 및 액세스 포인트 이름이 포함됩니다.

```
arn:aws:s3-outposts:region:account-id:outpost/outpost-id/accesspoint/accesspoint-name
```

S3 on Outposts ARN에 대한 자세한 내용은 [S3 on Outposts의 리소스 ARN](S3OutpostsIAM.md#S3OutpostsARN) 단원을 참조하세요.

**참고**  
Amazon S3 on Outposts를 사용할 경우 객체 데이터는 항상 Outpost에 저장됩니다. AWS가 Outpost 랙을 설치하는 경우 데이터 상주 요구 사항을 충족하기 위해 데이터가 Outpost에 로컬로 유지됩니다. 객체는 Outpost에서 벗어나지 않으며 AWS 리전에 있지 않습니다. AWS Management Console이 리전 내에 호스팅되므로 콘솔을 사용하여 Outpost의 객체를 업로드하거나 관리할 수 없습니다. 그러나 REST API, AWS Command Line Interface(AWS CLI), AWS SDK를 사용하여 액세스 포인트를 통해 객체를 업로드하고 관리할 수 있습니다.

다음 예제에서는 AWS CLI 및 AWS SDK for Java를 사용하여 S3 on Outposts 버킷의 객체를 나열하는 방법을 보여줍니다.

## AWS CLI 사용
<a name="S3OutpostsListObjectsCLI"></a>

다음 예제에서는 AWS CLI를 사용하여 S3 on Outposts 버킷(`s3-outposts:ListObjectsV2`)의 객체를 나열합니다. 이 명령을 사용하려면 각 `user input placeholder`를 사용자의 정보로 대체합니다. 이 명령에 대한 자세한 내용은 [AWS CLI 참조](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/list-objects-v2.html)의 *list-objects-v2*를 참조하세요.

```
aws s3api list-objects-v2 --bucket arn:aws:s3-outposts:region:123456789012:outpost/op-01ac5d28a6a232904/accesspoint/example-outposts-access-point
```

**참고**  
AWS SDK를 통해 Amazon S3 on Outposts에서 이 작업을 사용할 때 버킷 이름 대신 Outposts 액세스 포인트 ARN을 `arn:aws:s3-outposts:region:123456789012:outpost/op-01ac5d28a6a232904/accesspoint/example-Outposts-Access-Point` 형식으로 제공합니다. S3 on Outposts ARN에 대한 자세한 내용은 [S3 on Outposts의 리소스 ARN](S3OutpostsIAM.md#S3OutpostsARN) 단원을 참조하세요.

## Java용 AWS SDK 사용
<a name="S3OutpostsListObjectsJava"></a>

다음 S3 on Outposts 예제에서는 Java용 SDK를 사용하여 버킷의 객체를 나열합니다. 이 예제를 사용하려면 각 `user input placeholder`를 사용자의 정보로 대체합니다.

**중요**  
이 예제에서는 `ListObjects` API 작업의 최신 버전인 [ListObjectsV2](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html)를 사용합니다. 애플리케이션 개발 시 이 개정된 API 작업을 사용하는 것이 좋습니다. 이전 버전과의 호환성을 위해 Amazon S3는 이 API 작업의 이전 버전을 계속 지원합니다.

```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.ListObjectsV2Request;
import com.amazonaws.services.s3.model.ListObjectsV2Result;
import com.amazonaws.services.s3.model.S3ObjectSummary;

public class ListObjectsV2 {

    public static void main(String[] args) {
        String accessPointArn = "*** access point ARN ***";

        try {
            // This code expects that you have AWS credentials set up per:
            // https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .enableUseArnRegion()
                    .build();

            System.out.println("Listing objects");

            // maxKeys is set to 2 to demonstrate the use of
            // ListObjectsV2Result.getNextContinuationToken()
            ListObjectsV2Request req = new ListObjectsV2Request().withBucketName(accessPointArn).withMaxKeys(2);
            ListObjectsV2Result result;

            do {
                result = s3Client.listObjectsV2(req);

                for (S3ObjectSummary objectSummary : result.getObjectSummaries()) {
                    System.out.printf(" - %s (size: %d)\n", objectSummary.getKey(), objectSummary.getSize());
                }
                // If there are more than maxKeys keys in the bucket, get a continuation token
                // and list the next objects.
                String token = result.getNextContinuationToken();
                System.out.println("Next Continuation Token: " + token);
                req.setContinuationToken(token);
            } while (result.isTruncated());
        } catch (AmazonServiceException e) {
            // The call was transmitted successfully, but Amazon S3 couldn't process
            // it, so it returned an error response.
            e.printStackTrace();
        } catch (SdkClientException e) {
            // Amazon S3 couldn't be contacted for a response, or the client
            // couldn't parse the response from Amazon S3.
            e.printStackTrace();
        }
    }
}
```

# Amazon S3 on Outposts 버킷의 객체 삭제
<a name="S3OutpostsDeleteObject"></a>

객체는 Amazon S3 on Outposts에 저장되는 기본 개체입니다. 모든 객체는 어떤 버킷에 포함됩니다. Outpost 버킷의 객체에 액세스하려면 액세스 포인트를 사용해야 합니다. 객체 작업에 버킷을 지정할 때 액세스 포인트 이름이 포함된 액세스 포인트 Amazon 리소스 이름(ARN) 또는 액세스 포인트 별칭을 사용합니다. 액세스 포인트 별칭에 대한 자세한 내용은 [S3 on Outposts 버킷 액세스 포인트에 버킷 스타일 별칭 사용](s3-outposts-access-points-alias.md) 섹션을 참조하세요.

다음 예제는 S3 on Outposts 액세스 포인트에 대한 ARN 형식을 보여줍니다. 여기에는 Outpost가 있는 리전의 AWS 리전 코드, AWS 계정 ID, Outpost ID 및 액세스 포인트 이름이 포함됩니다.

```
arn:aws:s3-outposts:region:account-id:outpost/outpost-id/accesspoint/accesspoint-name
```

S3 on Outposts ARN에 대한 자세한 내용은 [S3 on Outposts의 리소스 ARN](S3OutpostsIAM.md#S3OutpostsARN) 단원을 참조하세요.

Amazon S3 on Outposts를 사용할 경우 객체 데이터는 항상 Outpost에 저장됩니다. AWS가 Outpost 랙을 설치하는 경우 데이터 상주 요구 사항을 충족하기 위해 데이터가 Outpost에 로컬로 유지됩니다. 객체는 Outpost에서 벗어나지 않으며 AWS 리전에 있지 않습니다. AWS Management Console이 리전 내에 호스팅되므로 콘솔을 사용하여 Outpost의 객체를 업로드하거나 관리할 수 없습니다. 그러나 REST API, AWS Command Line Interface(AWS CLI), AWS SDK를 사용하여 액세스 포인트를 통해 객체를 업로드하고 관리할 수 있습니다.

다음 예제에서는 AWS Command Line Interface(AWS CLI) 및 AWS SDK for Java를 사용하여 S3 on Outposts 버킷의 단일 객체 또는 여러 객체를 삭제하는 방법을 보여줍니다.

## AWS CLI 사용
<a name="S3OutpostsDeleteObjectsCLI"></a>

다음 예제에서는 S3 on Outposts 버킷에서 단일 객체 또는 여러 객체를 삭제하는 방법을 보여줍니다.







------
#### [ delete-object ]

다음 예제에서는 AWS CLI를 사용하여 S3 on Outposts 버킷(`s3-outposts:DeleteObject`)에서 `sample-object.xml`이라는 객체를 삭제합니다. 이 명령을 사용하려면 각 `user input placeholder`를 사용자의 정보로 대체합니다. 이 명령에 대한 자세한 내용은 *AWS CLI 참조*의 [delete-object](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/delete-object.html)를 참조하세요.

```
aws s3api delete-object --bucket arn:aws:s3-outposts:region:123456789012:outpost/op-01ac5d28a6a232904/accesspoint/example-outposts-access-point --key sample-object.xml
```

------
#### [ delete-objects ]

다음 예제에서는 AWS CLI를 사용하여 S3 on Outposts 버킷(`s3-outposts:DeleteObject`)에서 `sample-object.xml` 및 `test1.text`라는 두 객체를 삭제합니다. 이 명령을 사용하려면 각 `user input placeholder`를 사용자의 정보로 대체합니다. 이 명령에 대한 자세한 내용은 [AWS CLI 참조](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/delete-objects.html)의 *delete-objects*를 참조하세요.

```
aws s3api delete-objects --bucket arn:aws:s3-outposts:region:123456789012:outpost/op-01ac5d28a6a232904/accesspoint/example-outposts-access-point --delete file://delete.json

delete.json
{
  "Objects": [
    {
      "Key": "test1.txt"
    },
    {
      "Key": "sample-object.xml"
    }
  ],
  "Quiet": false
}
```

------

## Java용 AWS SDK 사용
<a name="S3OutpostsDeleteObjectsJava"></a>

다음 예제에서는 S3 on Outposts 버킷에서 단일 객체 또는 여러 객체를 삭제하는 방법을 보여줍니다.

------
#### [ DeleteObject ]

다음 S3 on Outposts 예제에서는 Java용 SDK를 사용하여 버킷의 객체를 삭제합니다. 이 예제를 사용하려면 Outpost에 대한 액세스 포인트 ARN과 삭제할 객체의 키 이름을 지정합니다. 자세한 내용은 *Amazon Simple Storage Service API 참조*에서 [DeleteObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObject.html)를 참조하세요.

```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.DeleteObjectRequest;

public class DeleteObject {
    public static void main(String[] args) {
        String accessPointArn = "*** access point ARN ***";
        String keyName = "*** key name ****";

        try {
            // This code expects that you have AWS credentials set up per:
            // https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .enableUseArnRegion()
                    .build();

            s3Client.deleteObject(new DeleteObjectRequest(accessPointArn, keyName));
        } catch (AmazonServiceException e) {
            // The call was transmitted successfully, but Amazon S3 couldn't process
            // it, so it returned an error response.
            e.printStackTrace();
        } catch (SdkClientException e) {
            // Amazon S3 couldn't be contacted for a response, or the client
            // couldn't parse the response from Amazon S3.
            e.printStackTrace();
        }
    }
}
```

------
#### [ DeleteObjects ]

다음 S3 on Outposts 예제에서는 Java용 SDK를 사용하여 버킷에 객체를 업로드하고 삭제합니다. 이 예제를 사용하려면 Outpost에 대한 액세스 포인트 ARN을 지정합니다. 자세한 내용은 *Amazon Simple Storage Service API 참조*에서 [DeleteObjects](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjects.html)를 참조하세요.

```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.DeleteObjectsRequest;
import com.amazonaws.services.s3.model.DeleteObjectsRequest.KeyVersion;
import com.amazonaws.services.s3.model.DeleteObjectsResult;

import java.util.ArrayList;

public class DeleteObjects {

    public static void main(String[] args) {
       String accessPointArn = "arn:aws:s3-outposts:region:123456789012:outpost/op-01ac5d28a6a232904/accesspoint/example-outposts-access-point";
        

        try {
            // This code expects that you have AWS credentials set up per:
            // https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .enableUseArnRegion()
                    .build();

            // Upload three sample objects.
            ArrayList<KeyVersion> keys = new ArrayList<KeyVersion>();
            for (int i = 0; i < 3; i++) {
                String keyName = "delete object example " + i;
                s3Client.putObject(accessPointArn, keyName, "Object number " + i + " to be deleted.");
                keys.add(new KeyVersion(keyName));
            }
            System.out.println(keys.size() + " objects successfully created.");

            // Delete the sample objects.
            DeleteObjectsRequest multiObjectDeleteRequest = new DeleteObjectsRequest(accessPointArn)
                    .withKeys(keys)
                    .withQuiet(false);

            // Verify that the objects were deleted successfully.
            DeleteObjectsResult delObjRes = s3Client.deleteObjects(multiObjectDeleteRequest);
            int successfulDeletes = delObjRes.getDeletedObjects().size();
            System.out.println(successfulDeletes + " objects successfully deleted.");
        } catch (AmazonServiceException e) {
            // The call was transmitted successfully, but Amazon S3 couldn't process
            // it, so it returned an error response.
            e.printStackTrace();
        } catch (SdkClientException e) {
            // Amazon S3 couldn't be contacted for a response, or the client
            // couldn't parse the response from Amazon S3.
            e.printStackTrace();
        }
    }
}
```

------

# HeadBucket을 사용하여 S3 on Outposts 버킷이 존재하고 버킷에 액세스할 수 있는 권한이 있는지 확인
<a name="S3OutpostsHeadBucket"></a>

객체는 Amazon S3 on Outposts에 저장되는 기본 개체입니다. 모든 객체는 어떤 버킷에 포함됩니다. Outpost 버킷의 객체에 액세스하려면 액세스 포인트를 사용해야 합니다. 객체 작업에 버킷을 지정할 때 액세스 포인트 이름이 포함된 액세스 포인트 Amazon 리소스 이름(ARN) 또는 액세스 포인트 별칭을 사용합니다. 액세스 포인트 별칭에 대한 자세한 내용은 [S3 on Outposts 버킷 액세스 포인트에 버킷 스타일 별칭 사용](s3-outposts-access-points-alias.md) 섹션을 참조하세요.

다음 예제는 S3 on Outposts 액세스 포인트에 대한 ARN 형식을 보여줍니다. 여기에는 Outpost가 있는 리전의 AWS 리전 코드, AWS 계정 ID, Outpost ID 및 액세스 포인트 이름이 포함됩니다.

```
arn:aws:s3-outposts:region:account-id:outpost/outpost-id/accesspoint/accesspoint-name
```

S3 on Outposts ARN에 대한 자세한 내용은 [S3 on Outposts의 리소스 ARN](S3OutpostsIAM.md#S3OutpostsARN) 단원을 참조하세요.

**참고**  
Amazon S3 on Outposts를 사용할 경우 객체 데이터는 항상 Outpost에 저장됩니다. AWS가 Outpost 랙을 설치하는 경우 데이터 상주 요구 사항을 충족하기 위해 데이터가 Outpost에 로컬로 유지됩니다. 객체는 Outpost에서 벗어나지 않으며 AWS 리전에 있지 않습니다. AWS Management Console이 리전 내에 호스팅되므로 콘솔을 사용하여 Outpost의 객체를 업로드하거나 관리할 수 없습니다. 그러나 REST API, AWS Command Line Interface(AWS CLI), AWS SDK를 사용하여 액세스 포인트를 통해 객체를 업로드하고 관리할 수 있습니다.

다음 AWS Command Line Interface(AWS CLI) 및 AWS SDK for Java 예제에서는 HeadBucket API 작업을 사용하여 Amazon S3 on Outposts 버킷이 존재하고 버킷에 액세스할 수 있는 권한이 있는지를 확인하는 방법을 보여줍니다. 자세한 내용은 [Amazon Simple Storage Service API 참조](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadBucket.html)의 *HeadBucket*를 참조하세요.

## AWS CLI 사용
<a name="S3OutpostsHeadBucketCLI"></a>

다음 S3 on Outposts AWS CLI 예제에서는 `head-bucket` 명령을 사용하여 버킷이 존재하고 버킷에 액세스할 수 있는 권한이 있는지를 확인합니다. 이 명령을 사용하려면 각 `user input placeholder`를 사용자의 정보로 대체합니다. 이 명령에 대한 자세한 내용은 *AWS CLI 참조*의 [head-bucket](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/head-bucket.html)을 참조하세요.

```
aws s3api head-bucket --bucket arn:aws:s3-outposts:region:123456789012:outpost/op-01ac5d28a6a232904/accesspoint/example-outposts-access-point
```

## Java용 AWS SDK 사용
<a name="S3OutpostsHeadBucketJava"></a>

다음 S3 on Outposts 예제에서는 버킷이 존재하고 버킷에 액세스할 수 있는 권한이 있는지 확인하는 방법을 보여줍니다. 이 예제를 사용하려면 Outpost에 대한 액세스 포인트 ARN을 지정합니다. 자세한 내용은 [Amazon Simple Storage Service API 참조](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadBucket.html)의 *HeadBucket*를 참조하세요.

```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.HeadBucketRequest;

public class HeadBucket {
    public static void main(String[] args) {
        String accessPointArn = "*** access point ARN ***";

        try {
            // This code expects that you have AWS credentials set up per:
            // https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .enableUseArnRegion()
                    .build();

            s3Client.headBucket(new HeadBucketRequest(accessPointArn));
        } catch (AmazonServiceException e) {
            // The call was transmitted successfully, but Amazon S3 couldn't process
            // it, so it returned an error response.
            e.printStackTrace();
        } catch (SdkClientException e) {
            // Amazon S3 couldn't be contacted for a response, or the client
            // couldn't parse the response from Amazon S3.
            e.printStackTrace();
        }
    }
}
```

# Java용 SDK를 사용하여 멀티파트 업로드 수행 및 관리
<a name="S3OutpostsMPU"></a>

Amazon S3 on Outposts를 사용하면 AWS Outposts 리소스에서 S3 버킷을 생성하고 로컬 데이터 액세스, 로컬 데이터 처리 및 데이터 레지던시가 필요한 애플리케이션을 위해 온프레미스에서 객체를 저장하고 검색할 수 있습니다. AWS Management Console, AWS Command Line Interface(AWS CLI), AWS SDK 또는 REST API를 통해 S3 on Outposts를 사용할 수 있습니다. 자세한 내용은 [Amazon S3 on Outposts란 무엇인가요?](S3onOutposts.md) 섹션을 참조하세요. 

다음 예제에서는 AWS SDK for Java와 함께 S3 on Outposts를 사용하여 멀티파트 업로드를 수행하고 관리하는 방법을 보여줍니다.

**Topics**
+ [S3 on Outposts 버킷에 있는 객체의 멀티파트 업로드 수행](#S3OutpostsInitiateMultipartUploadJava)
+ [멀티파트 업로드를 사용하여 S3 on Outposts 버킷에 있는 대형 객체 복사](#S3OutpostsCopyPartJava)
+ [S3 on Outposts 버킷에 있는 객체의 부분 나열](#S3OutpostsListPartsJava)
+ [S3 on Outposts 버킷에서 진행 중인 멀티파트 업로드 목록 검색](#S3OutpostsListMultipartUploadsJava)

## S3 on Outposts 버킷에 있는 객체의 멀티파트 업로드 수행
<a name="S3OutpostsInitiateMultipartUploadJava"></a>

다음 S3 on Outposts 예제에서는 Java용 SDK를 사용하여 버킷에 객체의 멀티파트 업로드를 시작, 업로드 및 완료합니다. 이 예제를 사용하려면 각 `user input placeholder`를 사용자의 정보로 대체합니다. 자세한 내용은 **Amazon Simple Storage Service 사용 설명서의 [멀티파트 업로드를 사용한 객체 업로드](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpu-upload-object.html)를 참조하세요.

```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.*;

import java.util.ArrayList;
import java.util.List;

public class MultipartUploadCopy {
    public static void main(String[] args) {
        String accessPointArn = "*** Source access point ARN ***";
        String sourceObjectKey = "*** Source object key ***";
        String destObjectKey = "*** Target object key ***";

        try {
            // This code expects that you have AWS credentials set up per:
            // https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .enableUseArnRegion()
                    .build();

            // Initiate the multipart upload.
            InitiateMultipartUploadRequest initRequest = new InitiateMultipartUploadRequest(accessPointArn, destObjectKey);
            InitiateMultipartUploadResult initResult = s3Client.initiateMultipartUpload(initRequest);

            // Get the object size to track the end of the copy operation.
            GetObjectMetadataRequest metadataRequest = new GetObjectMetadataRequest(accessPointArn, sourceObjectKey);
            ObjectMetadata metadataResult = s3Client.getObjectMetadata(metadataRequest);
            long objectSize = metadataResult.getContentLength();

            // Copy the object using 5 MB parts.
            long partSize = 5 * 1024 * 1024;
            long bytePosition = 0;
            int partNum = 1;
            List<CopyPartResult> copyResponses = new ArrayList<CopyPartResult>();
            while (bytePosition < objectSize) {
                // The last part might be smaller than partSize, so check to make sure
                // that lastByte isn't beyond the end of the object.
                long lastByte = Math.min(bytePosition + partSize - 1, objectSize - 1);

                // Copy this part.
                CopyPartRequest copyRequest = new CopyPartRequest()
                        .withSourceBucketName(accessPointArn)
                        .withSourceKey(sourceObjectKey)
                        .withDestinationBucketName(accessPointArn)
                        .withDestinationKey(destObjectKey)
                        .withUploadId(initResult.getUploadId())
                        .withFirstByte(bytePosition)
                        .withLastByte(lastByte)
                        .withPartNumber(partNum++);
                copyResponses.add(s3Client.copyPart(copyRequest));
                bytePosition += partSize;
            }

            // Complete the upload request to concatenate all uploaded parts and make the copied object available.
            CompleteMultipartUploadRequest completeRequest = new CompleteMultipartUploadRequest(
                    accessPointArn,
                    destObjectKey,
                    initResult.getUploadId(),
                    getETags(copyResponses));
            s3Client.completeMultipartUpload(completeRequest);
            System.out.println("Multipart copy complete.");
        } catch (AmazonServiceException e) {
            // The call was transmitted successfully, but Amazon S3 couldn't process 
            // it, so it returned an error response.
            e.printStackTrace();
        } catch (SdkClientException e) {
            // Amazon S3 couldn't be contacted for a response, or the client  
            // couldn't parse the response from Amazon S3.
            e.printStackTrace();
        }
    }

    // This is a helper function to construct a list of ETags.
    private static List<PartETag> getETags(List<CopyPartResult> responses) {
        List<PartETag> etags = new ArrayList<PartETag>();
        for (CopyPartResult response : responses) {
            etags.add(new PartETag(response.getPartNumber(), response.getETag()));
        }
        return etags;
    }
```

## 멀티파트 업로드를 사용하여 S3 on Outposts 버킷에 있는 대형 객체 복사
<a name="S3OutpostsCopyPartJava"></a>

다음 S3 on Outposts 예제에서는 Java용 SDK를 사용하여 버킷에 객체를 복사합니다. 이 예제를 사용하려면 각 `user input placeholder`를 사용자의 정보로 대체합니다.

```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.*;

import java.util.ArrayList;
import java.util.List;

public class MultipartUploadCopy {
    public static void main(String[] args) {
        String accessPointArn = "*** Source access point ARN ***";
        String sourceObjectKey = "*** Source object key ***";
        String destObjectKey = "*** Target object key ***";

        try {
            // This code expects that you have AWS credentials set up per:
            // https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .enableUseArnRegion()
                    .build();

            // Initiate the multipart upload.
            InitiateMultipartUploadRequest initRequest = new InitiateMultipartUploadRequest(accessPointArn, destObjectKey);
            InitiateMultipartUploadResult initResult = s3Client.initiateMultipartUpload(initRequest);

            // Get the object size to track the end of the copy operation.
            GetObjectMetadataRequest metadataRequest = new GetObjectMetadataRequest(accessPointArn, sourceObjectKey);
            ObjectMetadata metadataResult = s3Client.getObjectMetadata(metadataRequest);
            long objectSize = metadataResult.getContentLength();

            // Copy the object using 5 MB parts.
            long partSize = 5 * 1024 * 1024;
            long bytePosition = 0;
            int partNum = 1;
            List<CopyPartResult> copyResponses = new ArrayList<CopyPartResult>();
            while (bytePosition < objectSize) {
                // The last part might be smaller than partSize, so check to make sure
                // that lastByte isn't beyond the end of the object.
                long lastByte = Math.min(bytePosition + partSize - 1, objectSize - 1);

                // Copy this part.
                CopyPartRequest copyRequest = new CopyPartRequest()
                        .withSourceBucketName(accessPointArn)
                        .withSourceKey(sourceObjectKey)
                        .withDestinationBucketName(accessPointArn)
                        .withDestinationKey(destObjectKey)
                        .withUploadId(initResult.getUploadId())
                        .withFirstByte(bytePosition)
                        .withLastByte(lastByte)
                        .withPartNumber(partNum++);
                copyResponses.add(s3Client.copyPart(copyRequest));
                bytePosition += partSize;
            }

            // Complete the upload request to concatenate all uploaded parts and make the copied object available.
            CompleteMultipartUploadRequest completeRequest = new CompleteMultipartUploadRequest(
                    accessPointArn,
                    destObjectKey,
                    initResult.getUploadId(),
                    getETags(copyResponses));
            s3Client.completeMultipartUpload(completeRequest);
            System.out.println("Multipart copy complete.");
        } catch (AmazonServiceException e) {
            // The call was transmitted successfully, but Amazon S3 couldn't process 
            // it, so it returned an error response.
            e.printStackTrace();
        } catch (SdkClientException e) {
            // Amazon S3 couldn't be contacted for a response, or the client  
            // couldn't parse the response from Amazon S3.
            e.printStackTrace();
        }
    }

    // This is a helper function to construct a list of ETags.
    private static List<PartETag> getETags(List<CopyPartResult> responses) {
        List<PartETag> etags = new ArrayList<PartETag>();
        for (CopyPartResult response : responses) {
            etags.add(new PartETag(response.getPartNumber(), response.getETag()));
        }
        return etags;
    }
}
```

## S3 on Outposts 버킷에 있는 객체의 부분 나열
<a name="S3OutpostsListPartsJava"></a>

다음 S3 on Outposts 예제에서는 Java용 SDK를 사용하여 버킷의 객체 파트를 나열합니다. 이 예제를 사용하려면 각 `user input placeholder`를 사용자의 정보로 대체합니다.

```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.*;

import java.util.List;

public class ListParts {
    public static void main(String[] args) {
        String accessPointArn = "*** access point ARN ***";
        String keyName = "*** Key name ***";
        String uploadId = "*** Upload ID ***";

        try {
            // This code expects that you have AWS credentials set up per:
            // https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .enableUseArnRegion()
                    .build();

            ListPartsRequest listPartsRequest = new ListPartsRequest(accessPointArn, keyName, uploadId);
            PartListing partListing = s3Client.listParts(listPartsRequest);
            List<PartSummary> partSummaries = partListing.getParts();

            System.out.println(partSummaries.size() + " multipart upload parts");
            for (PartSummary p : partSummaries) {
                System.out.println("Upload part: Part number = \"" + p.getPartNumber() + "\", ETag = " + p.getETag());
            }

        } catch (AmazonServiceException e) {
            // The call was transmitted successfully, but Amazon S3 couldn't process
            // it, so it returned an error response.
            e.printStackTrace();
        } catch (SdkClientException e) {
            // Amazon S3 couldn't be contacted for a response, or the client
            // couldn't parse the response from Amazon S3.
            e.printStackTrace();
        }
    }
}
```

## S3 on Outposts 버킷에서 진행 중인 멀티파트 업로드 목록 검색
<a name="S3OutpostsListMultipartUploadsJava"></a>

다음 S3 on Outposts 예제에서는 Outposts 버킷에서 Java용 SDK를 사용하여 진행 중인 멀티파트 업로드 목록을 검색하는 방법을 보여줍니다. 이 예제를 사용하려면 각 `user input placeholder`를 사용자의 정보로 대체합니다.

```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.ListMultipartUploadsRequest;
import com.amazonaws.services.s3.model.MultipartUpload;
import com.amazonaws.services.s3.model.MultipartUploadListing;

import java.util.List;

public class ListMultipartUploads {
    public static void main(String[] args) {
                String accessPointArn = "*** access point ARN ***";

        try {
            // This code expects that you have AWS credentials set up per:
            // https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .enableUseArnRegion()
                    .build();

            // Retrieve a list of all in-progress multipart uploads.
            ListMultipartUploadsRequest allMultipartUploadsRequest = new ListMultipartUploadsRequest(accessPointArn);
            MultipartUploadListing multipartUploadListing = s3Client.listMultipartUploads(allMultipartUploadsRequest);
            List<MultipartUpload> uploads = multipartUploadListing.getMultipartUploads();

            // Display information about all in-progress multipart uploads.
            System.out.println(uploads.size() + " multipart upload(s) in progress.");
            for (MultipartUpload u : uploads) {
                System.out.println("Upload in progress: Key = \"" + u.getKey() + "\", id = " + u.getUploadId());
            }
        } catch (AmazonServiceException e) {
            // The call was transmitted successfully, but Amazon S3 couldn't process
            // it, so it returned an error response.
            e.printStackTrace();
        } catch (SdkClientException e) {
            // Amazon S3 couldn't be contacted for a response, or the client
            // couldn't parse the response from Amazon S3.
            e.printStackTrace();
        }
    }
}
```

# S3 on Outposts에서 미리 서명된 URL 사용
<a name="S3OutpostsPresignedURL"></a>

버킷 정책을 업데이트하지 않고 Outpost에 로컬로 저장된 객체에 한시적 액세스 권한을 부여하려면 미리 서명된 URL을 사용할 수 있습니다. 버킷 소유자는 미리 서명된 URL을 사용하여 Virtual Private Cloud(VPC)의 사용자와 객체를 공유하거나 이들에게 객체를 업로드 또는 삭제할 수 있는 권한을 부여할 수 있습니다.

AWS SDK 또는 AWS Command Line Interface(AWS CLI)를 사용하여 미리 서명된 URL을 생성하면 URL을 특정 작업과 연결합니다. 또한 최소 1초 및 최대 7일의 사용자 지정 만료 시간을 선택하여 미리 서명된 URL에 대한 한시적 액세스 권한을 부여할 수 있습니다. 미리 서명된 URL을 공유하면 VPC의 사용자가 원래 서명 사용자인 것처럼 URL에 포함된 작업을 수행할 수 있습니다. URL이 만료 시간에 도달하면 URL이 만료되고 더 이상 작동하지 않습니다.

## 미리 서명된 URL 기능 제한
<a name="S3OutpostsPresignedUrlUploadObjectLimitCapabilities"></a>

미리 서명된 URL의 기능은 이를 만든 사용자의 권한에 의해 제한됩니다. 미리 서명된 URL은 기본적으로 이를 소유한 사용자에게 액세스 권한을 부여하는 보유자 토큰입니다. 따라서 이러한 URL은 적절하게 보호하는 것이 좋습니다.

**AWS Signature Version 4(SigV4)**  
사전 서명된 URL 요청이 AWS Signature Version 4(SigV4)를 사용하여 인증될 때 특정 동작을 적용하기 위해 버킷 정책 및 액세스 포인트 정책에서 조건 키를 사용할 수 있습니다. 예를 들어 서명이 10분 이상 지난 경우, `example-outpost-bucket` 버킷의 객체에 대한 Amazon S3 on Outposts 사전 서명된 URL 요청을 거부하는 `s3-outposts:signatureAge` 조건을 사용하는 버킷 정책을 생성할 수 있습니다. 이 예제를 사용하려면 *`user input placeholders`*를 사용자의 정보로 대체합니다.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "Deny a presigned URL request if the signature is more than 10 minutes old",
            "Effect": "Deny",
            "Principal": {"AWS":"444455556666"},
            "Action": "s3-outposts:*",
            "Resource": "arn:aws:s3-outposts:us-east-1:111122223333:outpost/op-01ac5d28a6a232904/bucket/example-outpost-bucket/object/*",
            "Condition": {
                "NumericGreaterThan": {"s3-outposts:signatureAge": 600000},
                "StringEquals": {"s3-outposts:authType": "REST-QUERY-STRING"}
            }
        }
    ]
}
```

------

사전 서명된 URL 요청이 서명 버전 4를 사용하여 인증될 때 특정 동작을 적용하는 데 사용할 수 있는 조건 키 및 추가 예제 정책 목록은 [AWS Signature Version 4(SigV4) 인증별 정책 키](s3-outposts-bucket-policy-s3-sigv4-conditions.md) 섹션을 참조하세요.

**네트워크 경로 제한**  
특정 네트워크 경로에 대해 미리 서명된 URL 및 모든 S3 on Outposts 액세스의 사용을 제한하려는 경우, 특정 네트워크 경로가 필요한 정책을 작성할 수 있습니다. 호출을 실행하는 IAM 보안 주체에 대한 제한을 설정하려면 자격 증명 기반 AWS Identity and Access Management(IAM) 정책(예: 사용자, 그룹 또는 역할 정책)을 사용할 수 있습니다. S3 on Outposts 리소스에 대한 제한을 설정하려면 리소스 기반 정책(예: 버킷 및 액세스 포인트 정책)을 사용할 수 있습니다.

IAM 보안 주체에 대한 네트워크 경로 제한은 해당 보안 인증 정보의 사용자가 지정된 네트워크에서 요청해야 합니다. 버킷 또는 액세스 포인트에 대한 제한은 해당 리소스에 대한 모든 요청이 지정된 네트워크에서 시작되도록 요구합니다. 이러한 제한은 미리 서명된 URL 시나리오 외부에서도 적용됩니다.

사용하는 IAM 전역 조건은 엔드포인트 유형에 따라 달라집니다. S3 on Outposts용 퍼블릭 엔드포인트를 사용하는 경우 `aws:SourceIp`를 사용합니다. S3 on Outposts용 VPC 엔드포인트를 사용하는 경우 `aws:SourceVpc` 또는 `aws:SourceVpce`를 사용합니다.

다음 IAM 정책 설명에서는 보안 주체가 지정된 네트워크 범위에서만 AWS에 액세스해야 합니다. 이 정책 설명을 사용하면 모든 액세스가 해당 범위에서 시작되어야 합니다. 여기에는 S3 on Outposts에 대해 미리 서명된 URL을 사용하는 사례가 포함됩니다. 이 예제를 사용하려면 *`user input placeholders`*를 사용자의 정보로 대체합니다.

```
{
    "Sid": "NetworkRestrictionForIAMPrincipal",
    "Effect": "Deny",
    "Action": "*",
    "Resource": "*",
    "Condition": {
        "NotIpAddressIfExists": {"aws:SourceIp": "IP-address-range"},
        "BoolIfExists": {"aws:ViaAWSService": "false"}
    }
}
```

`aws:SourceIP` AWS 전역 조건 키를 사용하여 S3 on Outposts 버킷에 대한 액세스를 특정 네트워크 범위로 제한하는 버킷 정책 예제는 [S3 on Outposts로 IAM 설정](S3OutpostsIAM.md) 섹션을 참조하세요.

## 미리 서명된 URL을 생성할 수 있는 사용자
<a name="S3Outpostswho-presigned-url"></a>

유효한 보안 자격 증명을 가진 사용자는 누구나 미리 서명된 URL을 만들 수 있습니다. 단, VPC의 사용자가 객체에 성공적으로 액세스하려면 미리 서명된 URL의 기반이 되는 작업을 수행할 권한이 있는 사람이 미리 서명된 URL을 생성해야 합니다.

다음 보안 인증 정보를 사용하여 미리 서명된 URL을 만들 수 있습니다.
+ **IAM 인스턴스 프로파일**: 최대 6시간 동안 유효함.
+ **AWS Security Token Service**: AWS 계정 계정 루트 사용자 또는 IAM 사용자의 보안 인증 정보 등의 영구 보안 인증 정보를 통해 서명된 경우 최대 36시간 동안 유효함.
+ **IAM 사용자**: AWS 서명 버전 4를 사용할 경우 최대 7일 동안 유효함.

  최대 7일 동안 유효한 미리 서명된 URL을 생성하려면 먼저 IAM 사용자 보안 인증 정보(액세스 키 및 비밀 키)를 사용 중인 SDK에 위임합니다. 그런 다음 AWS 서명 버전 4를 사용하여 미리 서명된 URL을 생성합니다.

**참고**  
임시 토큰을 사용하여 미리 서명된 URL을 생성할 경우, URL의 만료 시간이 토큰 만료 시간보다 이후인 경우에도 토큰이 만료되면 URL도 만료됩니다.
미리 서명된 URL은 해당 URL을 소유한 모든 사람에게 S3 on Outposts 버킷에 대한 액세스 권한을 부여하므로, URL을 적절하게 보호하는 것이 좋습니다. 미리 서명된 URL 보호에 대한 자세한 내용은 [미리 서명된 URL 기능 제한](#S3OutpostsPresignedUrlUploadObjectLimitCapabilities) 섹션을 참조하세요.

## S3 on Outposts는 미리 서명된 URL의 만료 날짜 및 시간을 언제 확인하나요?
<a name="S3Outpostspresigned-url-when-checked"></a>

HTTP 요청 시 S3 on Outposts는 서명된 URL의 만료 날짜와 시간을 확인합니다. 예를 들어 클라이언트가 만료 시간 직전에 대용량 파일을 다운로드하기 시작한 경우, 다운로드 중에 만료 시간이 경과해도 다운로드는 진행됩니다. 단, 연결이 끊어진 경우 클라이언트가 만료 시간 이후에 다운로드를 다시 시작하는 것은 불가능합니다.

미리 서명된 URL을 사용하여 객체를 공유하거나 업로드하는 방법에 대한 자세한 내용은 다음 주제를 참조하세요.

**Topics**
+ [미리 서명된 URL 기능 제한](#S3OutpostsPresignedUrlUploadObjectLimitCapabilities)
+ [미리 서명된 URL을 생성할 수 있는 사용자](#S3Outpostswho-presigned-url)
+ [S3 on Outposts는 미리 서명된 URL의 만료 날짜 및 시간을 언제 확인하나요?](#S3Outpostspresigned-url-when-checked)
+ [미리 서명된 URL을 사용하여 객체 공유](S3OutpostsShareObjectPresignedURL.md)
+ [미리 서명된 URL을 생성하여 S3 on Outposts 버킷에 객체 업로드](S3OutpostsPresignedUrlUploadObject.md)

# 미리 서명된 URL을 사용하여 객체 공유
<a name="S3OutpostsShareObjectPresignedURL"></a>

버킷 정책을 업데이트하지 않고 Outpost에 로컬로 저장된 객체에 한시적 액세스 권한을 부여하려면 미리 서명된 URL을 사용할 수 있습니다. 버킷 소유자는 미리 서명된 URL을 사용하여 Virtual Private Cloud(VPC)의 사용자와 객체를 공유하거나 이들에게 객체를 업로드 또는 삭제할 수 있는 권한을 부여할 수 있습니다.

AWS SDK 또는 AWS Command Line Interface(AWS CLI)를 사용하여 미리 서명된 URL을 생성하면 URL을 특정 작업과 연결합니다. 또한 최소 1초 및 최대 7일의 사용자 지정 만료 시간을 선택하여 미리 서명된 URL에 대한 한시적 액세스 권한을 부여할 수 있습니다. 미리 서명된 URL을 공유하면 VPC의 사용자가 원래 서명 사용자인 것처럼 URL에 포함된 작업을 수행할 수 있습니다. URL이 만료 시간에 도달하면 URL이 만료되고 더 이상 작동하지 않습니다.



미리 서명된 URL을 생성하면 보안 인증 정보를 제공한 후 다음을 지정해야 합니다.
+ Amazon S3 on Outposts 버킷에 대한 액세스 포인트 Amazon 리소스 이름(ARN)
+ 객체 키
+ HTTP 메서드(객체 다운로드를 위한 `GET`)
+ 만료 날짜 및 시간

미리 서명된 URL은 지정된 기간 동안만 유효합니다. 즉, 만료 날짜 및 시간 전에 URL에서 허용하는 작업을 시작해야 합니다. 미리 서명된 URL은 만료 날짜 및 시간까지 여러 번 사용할 수 있습니다. 임시 토큰을 사용하여 미리 서명된 URL을 생성할 경우, URL의 만료 시간이 토큰 만료 시간보다 이후인 경우에도 토큰이 만료되면 URL도 만료됩니다.

미리 서명된 URL에 액세스할 수 있는 Virtual Private Cloud(VPC) 사용자는 객체에 액세스할 수 있습니다. 예를 들어, 버킷에 동영상이 있고 버킷과 객체 모두 비공개인 경우 미리 서명된 URL을 만들어 다른 사용자와 동영상을 공유할 수 있습니다. 미리 서명된 URL은 해당 URL을 소유한 모든 사람에게 S3 on Outposts 버킷에 대한 액세스 권한을 부여하므로, URL을 적절하게 보호하는 것이 좋습니다. 미리 서명된 URL 보호에 대한 자세한 내용은 [미리 서명된 URL 기능 제한](S3OutpostsPresignedURL.md#S3OutpostsPresignedUrlUploadObjectLimitCapabilities) 섹션을 참조하세요.

유효한 보안 자격 증명을 가진 사용자는 누구나 미리 서명된 URL을 만들 수 있습니다. 단, 미리 서명된 URL은 미리 서명된 URL에서 제공하려는 작업을 수행할 권한이 있는 사용자가 생성해야 합니다. 자세한 내용은 [미리 서명된 URL을 생성할 수 있는 사용자](S3OutpostsPresignedURL.md#S3Outpostswho-presigned-url) 섹션을 참조하세요.

AWS SDK 및 AWS CLI를 사용하여 S3 on Outposts 버킷에 있는 객체를 공유할 미리 서명된 URL을 생성할 수 있습니다. 자세한 정보는 다음 예를 참조하십시오.

## AWS SDK 사용
<a name="S3OutpostsShareObjectPreSignedURLSDK"></a>

AWS SDK를 사용하여 객체를 검색할 수 있도록 다른 사용자에게 제공할 미리 서명된 URL을 생성할 수 있습니다.

**참고**  
AWS SDK를 사용하여 미리 서명된 URL을 생성할 때 미리 서명된 URL의 최대 만료 시간은 생성 시점으로부터 7일입니다.

------
#### [ Java ]

**Example**  
다음 예제에서는 S3 on Outposts 버킷에서 객체를 검색할 수 있도록 다른 사용자에게 제공할 미리 서명된 URL을 생성합니다. 자세한 내용은 [S3 on Outposts에서 미리 서명된 URL 사용](S3OutpostsPresignedURL.md) 섹션을 참조하세요. 이 예제를 사용하려면 *`user input placeholders`*를 사용자의 정보로 대체합니다.  

```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.HttpMethod;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.GeneratePresignedUrlRequest;

import java.io.IOException;
import java.net.URL;
import java.time.Instant;

public class GeneratePresignedURL {

    public static void main(String[] args) throws IOException {
        Regions clientRegion = Regions.DEFAULT_REGION;
        String accessPointArn = "*** access point ARN ***";
        String objectKey = "*** object key ***";

        try {
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .withRegion(clientRegion)
                    .withCredentials(new ProfileCredentialsProvider())
                    .build();

            // Set the presigned URL to expire after one hour.
            java.util.Date expiration = new java.util.Date();
            long expTimeMillis = Instant.now().toEpochMilli();
            expTimeMillis += 1000 * 60 * 60;
            expiration.setTime(expTimeMillis);

            // Generate the presigned URL.
            System.out.println("Generating pre-signed URL.");
            GeneratePresignedUrlRequest generatePresignedUrlRequest =
                    new GeneratePresignedUrlRequest(accessPointArn, objectKey)
                            .withMethod(HttpMethod.GET)
                            .withExpiration(expiration);
            URL url = s3Client.generatePresignedUrl(generatePresignedUrlRequest);

            System.out.println("Pre-Signed URL: " + url.toString());
        } catch (AmazonServiceException e) {
            // The call was transmitted successfully, but Amazon S3 couldn't process 
            // it, so it returned an error response.
            e.printStackTrace();
        } catch (SdkClientException e) {
            // Amazon S3 couldn't be contacted for a response, or the client
            // couldn't parse the response from Amazon S3.
            e.printStackTrace();
        }
    }
}
```

------
#### [ .NET ]

**Example**  
다음 예제에서는 S3 on Outposts 버킷에서 객체를 검색할 수 있도록 다른 사용자에게 제공할 미리 서명된 URL을 생성합니다. 자세한 내용은 [S3 on Outposts에서 미리 서명된 URL 사용](S3OutpostsPresignedURL.md) 섹션을 참조하세요. 이 예제를 사용하려면 *`user input placeholders`*를 사용자의 정보로 대체합니다.  

```
using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using System;

namespace Amazon.DocSamples.S3
{
    class GenPresignedURLTest
    {
        private const string accessPointArn = "*** access point ARN ***"; 
        private const string objectKey = "*** object key ***";
        // Specify how long the presigned URL lasts, in hours.
        private const double timeoutDuration = 12;
        // Specify your bucket Region (an example Region is shown).
        private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
        private static IAmazonS3 s3Client;

        public static void Main()
        {
            s3Client = new AmazonS3Client(bucketRegion);
            string urlString = GeneratePreSignedURL(timeoutDuration);
        }
        static string GeneratePreSignedURL(double duration)
        {
            string urlString = "";
            try
            {
                GetPreSignedUrlRequest request1 = new GetPreSignedUrlRequest
                {
                    BucketName = accessPointArn,
                    Key = objectKey,
                    Expires = DateTime.UtcNow.AddHours(duration)
                };
                urlString = s3Client.GetPreSignedURL(request1);
            }
            catch (AmazonS3Exception e)
            {
                Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
            }
            catch (Exception e)
            {
                Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
            }
            return urlString;
        }
    }
}
```

------
#### [ Python ]

다음 예제에서는 미리 서명된 URL을 생성하여 SDK for Python(Boto3)을 사용해 객체를 공유합니다. 예를 들어 Boto3 클라이언트와 `generate_presigned_url` 함수를 사용하여 객체를 `GET`할 수 있는 미리 서명된 URL을 생성합니다.

```
import boto3
    url = boto3.client('s3').generate_presigned_url(
    ClientMethod='get_object', 
    Params={'Bucket': 'ACCESS_POINT_ARN', 'Key': 'OBJECT_KEY'},
    ExpiresIn=3600)
```

SDK for Python(Boto3)을 사용하여 미리 서명된 URL을 생성하는 방법에 대한 자세한 내용은 *AWS SDK for Python (Boto) API 참조*의 [Python](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/s3.html#S3.Client.generate_presigned_url)을 참조하세요.

------

## AWS CLI 사용
<a name="S3OutpostsShareObjectPresignedCLI"></a>

다음 예제에서 AWS CLI 명령은 S3 on Outposts 버킷에 대해 미리 서명된 URL을 생성합니다. 이 예제를 사용하려면 *`user input placeholders`*를 사용자의 정보로 대체합니다.

**참고**  
AWS CLI를 사용하여 미리 서명된 URL을 생성할 때 미리 서명된 URL의 최대 만료 시간은 생성 시점으로부터 7일입니다.

```
aws s3 presign s3://arn:aws:s3-outposts:us-east-1:111122223333:outpost/op-01ac5d28a6a232904/accesspoint/example-outpost-access-point/mydoc.txt --expires-in 604800
```

자세한 내용은 *AWS CLI 명령 참조 안내서*의 [미리 서명](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3/presign.html)을 참조하세요.

# 미리 서명된 URL을 생성하여 S3 on Outposts 버킷에 객체 업로드
<a name="S3OutpostsPresignedUrlUploadObject"></a>

버킷 정책을 업데이트하지 않고 Outpost에 로컬로 저장된 객체에 한시적 액세스 권한을 부여하려면 미리 서명된 URL을 사용할 수 있습니다. 버킷 소유자는 미리 서명된 URL을 사용하여 Virtual Private Cloud(VPC)의 사용자와 객체를 공유하거나 이들에게 객체를 업로드 또는 삭제할 수 있는 권한을 부여할 수 있습니다.

AWS SDK 또는 AWS Command Line Interface(AWS CLI)를 사용하여 미리 서명된 URL을 생성하면 URL을 특정 작업과 연결합니다. 또한 최소 1초 및 최대 7일의 사용자 지정 만료 시간을 선택하여 미리 서명된 URL에 대한 한시적 액세스 권한을 부여할 수 있습니다. 미리 서명된 URL을 공유하면 VPC의 사용자가 원래 서명 사용자인 것처럼 URL에 포함된 작업을 수행할 수 있습니다. URL이 만료 시간에 도달하면 URL이 만료되고 더 이상 작동하지 않습니다.

미리 서명된 URL을 생성하면 보안 인증 정보를 제공한 후 다음을 지정해야 합니다.
+ Amazon S3 on Outposts 버킷에 대한 액세스 포인트 Amazon 리소스 이름(ARN)
+ 객체 키
+ HTTP 메서드(객체 업로드를 위한 `PUT`)
+ 만료 날짜 및 시간

미리 서명된 URL은 지정된 기간 동안만 유효합니다. 즉, 만료 날짜 및 시간 전에 URL에서 허용하는 작업을 시작해야 합니다. 미리 서명된 URL은 만료 날짜 및 시간까지 여러 번 사용할 수 있습니다. 임시 토큰을 사용하여 미리 서명된 URL을 생성할 경우, URL의 만료 시간이 토큰 만료 시간보다 이후인 경우에도 토큰이 만료되면 URL도 만료됩니다.

미리 서명된 URL에서 허용하는 작업이 멀티파트 업로드와 같이 여러 단계로 구성된 경우 만료 시간 전에 모든 단계를 시작해야 합니다. S3 on Outposts가 만료된 URL로 단계를 시작하려고 시도하는 경우 오류가 발생합니다.

미리 서명된 URL에 액세스할 수 있는 Virtual Private Cloud(VPC)의 사용자는 객체를 업로드할 수 있습니다. 예를 들어 미리 서명된 URL에 액세스할 수 있는 VPC의 사용자는 버킷에 객체를 업로드할 수 있습니다. 미리 서명된 URL은 미리 서명된 URL에 액세스할 수 있는 VPC의 모든 사용자에게 S3 on Outposts 버킷에 대한 액세스 권한을 부여하므로, URL을 적절하게 보호하는 것이 좋습니다. 미리 서명된 URL 보호에 대한 자세한 내용은 [미리 서명된 URL 기능 제한](S3OutpostsPresignedURL.md#S3OutpostsPresignedUrlUploadObjectLimitCapabilities) 섹션을 참조하세요.

유효한 보안 자격 증명을 가진 사용자는 누구나 미리 서명된 URL을 만들 수 있습니다. 단, 미리 서명된 URL은 미리 서명된 URL에서 제공하려는 작업을 수행할 권한이 있는 사용자가 생성해야 합니다. 자세한 내용은 [미리 서명된 URL을 생성할 수 있는 사용자](S3OutpostsPresignedURL.md#S3Outpostswho-presigned-url) 섹션을 참조하세요.

## AWS SDK를 사용하여 S3 on Outposts 객체 작업에 대한 미리 서명된 URL 생성
<a name="s3-outposts-presigned-urls-upload-examples"></a>

------
#### [ Java ]

**SDK for Java 2.x**  
이 예제는 한시적으로 S3 on Outposts 버킷에 객체를 업로드하는 데 사용할 수 있는 미리 서명된 URL을 생성하는 방법을 보여줍니다. 자세한 내용은 [S3 on Outposts에서 미리 서명된 URL 사용](S3OutpostsPresignedURL.md) 섹션을 참조하세요.  

```
    public static void signBucket(S3Presigner presigner, String outpostAccessPointArn, String keyName) {

        try {
            PutObjectRequest objectRequest = PutObjectRequest.builder()
                    .bucket(accessPointArn)
                    .key(keyName)
                    .contentType("text/plain")
                    .build();

            PutObjectPresignRequest presignRequest = PutObjectPresignRequest.builder()
                    .signatureDuration(Duration.ofMinutes(10))
                    .putObjectRequest(objectRequest)
                    .build();

            PresignedPutObjectRequest presignedRequest = presigner.presignPutObject(presignRequest);


            String myURL = presignedRequest.url().toString();
            System.out.println("Presigned URL to upload a file to: " +myURL);
            System.out.println("Which HTTP method must be used when uploading a file: " +
                    presignedRequest.httpRequest().method());

            // Upload content to the S3 on Outposts bucket by using this URL.
            URL url = presignedRequest.url();

            // Create the connection and use it to upload the new object by using the presigned URL.
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setDoOutput(true);
            connection.setRequestProperty("Content-Type","text/plain");
            connection.setRequestMethod("PUT");
            OutputStreamWriter out = new OutputStreamWriter(connection.getOutputStream());
            out.write("This text was uploaded as an object by using a presigned URL.");
            out.close();

            connection.getResponseCode();
            System.out.println("HTTP response code is " + connection.getResponseCode());

        } catch (S3Exception e) {
            e.getStackTrace();
        } catch (IOException e) {
            e.getStackTrace();
        }
    }
```

------
#### [ Python ]

**SDK for Python(Boto3)**  
이 예제는 한시적으로 S3 on Outposts 작업을 수행할 수 있는 미리 서명된 URL을 생성하는 방법을 보여줍니다. 자세한 내용은 [S3 on Outposts에서 미리 서명된 URL 사용](S3OutpostsPresignedURL.md) 섹션을 참조하세요. URL을 사용하여 요청하려면 `Requests` 패키지를 사용하세요.  

```
import argparse
import logging
import boto3
from botocore.exceptions import ClientError
import requests

logger = logging.getLogger(__name__)


def generate_presigned_url(s3_client, client_method, method_parameters, expires_in):
    """
    Generate a presigned S3 on Outposts URL that can be used to perform an action.

    :param s3_client: A Boto3 Amazon S3 client.
    :param client_method: The name of the client method that the URL performs.
    :param method_parameters: The parameters of the specified client method.
    :param expires_in: The number of seconds that the presigned URL is valid for.
    :return: The presigned URL.
    """
    try:
        url = s3_client.generate_presigned_url(
            ClientMethod=client_method,
            Params=method_parameters,
            ExpiresIn=expires_in
        )
        logger.info("Got presigned URL: %s", url)
    except ClientError:
        logger.exception(
            "Couldn't get a presigned URL for client method '%s'.", client_method)
        raise
    return url


def usage_demo():
    logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')

    print('-'*88)
    print("Welcome to the Amazon S3 on Outposts presigned URL demo.")
    print('-'*88)

    parser = argparse.ArgumentParser()
    parser.add_argument('accessPointArn', help="The name of the S3 on Outposts access point ARN.")
    parser.add_argument(
        'key', help="For a GET operation, the key of the object in S3 on Outposts. For a "
                    "PUT operation, the name of a file to upload.")
    parser.add_argument(
        'action', choices=('get', 'put'), help="The action to perform.")
    args = parser.parse_args()

    s3_client = boto3.client('s3')
    client_action = 'get_object' if args.action == 'get' else 'put_object'
    url = generate_presigned_url(
        s3_client, client_action, {'Bucket': args.accessPointArn, 'Key': args.key}, 1000)

    print("Using the Requests package to send a request to the URL.")
    response = None
    if args.action == 'get':
        response = requests.get(url)
    elif args.action == 'put':
        print("Putting data to the URL.")
        try:
            with open(args.key, 'r') as object_file:
                object_text = object_file.read()
            response = requests.put(url, data=object_text)
        except FileNotFoundError:
            print(f"Couldn't find {args.key}. For a PUT operation, the key must be the "
                  f"name of a file that exists on your computer.")

    if response is not None:
        print("Got response:")
        print(f"Status: {response.status_code}")
        print(response.text)

    print('-'*88)


if __name__ == '__main__':
    usage_demo()
```

------

# 로컬 Amazon EMR on Outposts를 사용하는 Amazon S3 on Outposts
<a name="s3-outposts-emr"></a>

Amazon EMR은 AWS에서 Apache Hadoop 및 Apache Spark와 같은 빅 데이터 프레임워크 실행을 단순화하여 방대한 양의 데이터를 처리하고 분석하는 관리형 클러스터 플랫폼입니다. 이러한 프레임워크 및 관련 오픈 소스 프로젝트를 사용하면 분석 목적 및 비즈니스 인텔리전스 워크로드용 데이터를 처리할 수 있습니다. 또한 Amazon EMR은 대량의 데이터를 다른 AWS 데이터 스토어 및 데이터베이스로 변환하고 이동하는 데 도움이 되며, Amazon S3 on Outposts를 지원합니다. Amazon EMR에 대한 자세한 내용은 **Amazon EMR 관리 안내서의 [Amazon EMR on Outposts](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-outposts.html)를 참조하세요.

Amazon S3 on Outposts의 경우, Amazon EMR은 버전 7.0.0에서 Apache Hadoop S3A 커넥터를 지원하기 시작했습니다. 이전 버전의 Amazon EMR은 로컬 S3 on Outposts를 지원하지 않으며 EMR 파일 시스템(EMRFS)은 지원되지 않습니다.

**지원되는 애플리케이션**  
Amazon S3 on Outposts를 사용하는 Amazon EMR은 다음과 같은 애플리케이션을 지원합니다.
+ Hadoop
+ Spark
+ Hue
+ Hive
+ Sqoop
+ Pig
+ Hudi
+ Flink

자세한 내용은 [Amazon EMR 릴리스 안내서](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-release-components.html)를 참조하세요.

## Amazon S3 on Outposts 버킷 생성 및 구성
<a name="create-outposts-bucket"></a>

Amazon EMR은 Amazon S3 on Outposts와 AWS SDK for Java를 사용하여 입력 데이터와 출력 데이터를 저장합니다. Amazon EMR 로그 파일은 사용자가 선택한 리전 Amazon S3 위치에 저장되며 Outpost에 로컬로 저장되지는 않습니다. 자세한 내용은 **Amazon EMR 관리 안내서에서 [Amazon EMR 로그](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-manage-view-web-log-files.html)를 참조하세요.

Amazon S3 및 DNS 요구 사항을 준수하기 위해 S3 on Outposts 버킷에는 이름 지정 제한 및 제한 사항이 있습니다. 자세한 내용은 [S3 on Outposts 버킷 생성](S3OutpostsCreateBucket.md) 섹션을 참조하세요.

Amazon EMR 버전 7.0.0 이상에서는 Amazon EMR을 S3 on Outposts 및 S3A 파일 시스템과 함께 사용할 수 있습니다.

**사전 조건**  
**S3 on Outposts 권한** - Amazon EMR 인스턴스 프로파일을 생성할 때 역할에 S3 on Outposts에 대한 AWS Identity and Access Management(IAM) 네임스페이스가 포함되어야 합니다. S3 on Outposts에는 자체 네임스페이스인 `s3-outposts*`가 있습니다. 이 네임스페이스를 사용하는 정책 예제는 [S3 on Outposts로 IAM 설정](S3OutpostsIAM.md) 섹션을 참조하세요.

**S3A 커넥터** - EMR 클러스터가 Amazon S3 on Outposts 버킷의 데이터에 액세스하도록 구성하려면 Apache Hadoop S3A 커넥터를 사용해야 합니다. 커넥터를 사용하려면 모든 S3 URI가 `s3a` 체계를 사용하는지 확인해야 합니다. 그렇지 않은 경우 S3 URI가 S3A 커넥터와 함께 작동하도록 EMR 클러스터에 사용하는 파일 시스템 구현을 구성할 수 있습니다.

S3A 커넥터와 함께 작동하도록 파일 시스템 구현을 구성하려면 `file_scheme`이 보유한 S3 URI 유형에 해당하는 EMR 클러스터의 `fs.file_scheme.impl` 및 `fs.AbstractFileSystem.file_scheme.impl` 구성 속성을 사용합니다. 다음 예시를 사용하려면 *`user input placeholders`*를 실제 정보로 대체하세요. 예를 들어, 이 `s3` 체계를 사용하는 S3 URI의 파일 시스템 구현을 변경하려면 다음 클러스터 구성 속성을 지정합니다.

```
1. [
2.   {
3. "Classification": "core-site",
4.     "Properties": {
5.     "fs.s3.impl": "org.apache.hadoop.fs.s3a.S3AFileSystem",
6.     "fs.AbstractFileSystem.s3.impl": "org.apache.hadoop.fs.s3a.S3A"
7.     }
8.   }
9. ]
```

S3A를 사용하려면 `fs.file_scheme.impl` 구성 속성을 `org.apache.hadoop.fs.s3a.S3AFileSystem`으로 설정하고 `fs.AbstractFileSystem.file_scheme.impl` 속성을 `org.apache.hadoop.fs.s3a.S3A`로 설정합니다.

예를 들어 경로 `s3a://bucket/...`에 액세스하는 경우 `fs.s3a.impl` 속성을 `org.apache.hadoop.fs.s3a.S3AFileSystem`으로 설정하고 `fs.AbstractFileSystem.s3a.impl` 속성을 `org.apache.hadoop.fs.s3a.S3A`로 설정합니다.

## Amazon S3 on Outposts를 사용하여 Amazon EMR 사용 시작
<a name="getting-started-outposts"></a>

다음 주제에서는 Amazon S3 on Outposts를 사용하여 Amazon EMR 사용을 시작하는 방법을 알아봅니다.

**Topics**
+ [권한 정책 생성](#create-permission-policy)
+ [클러스터 생성 및 구성](#configure-cluster)
+ [구성 개요](#configurations-overview)
+ [고려 사항](#considerations)

### 권한 정책 생성
<a name="create-permission-policy"></a>

Amazon S3 on Outposts를 사용하는 EMR 클러스터를 생성하기 전에 클러스터의 Amazon EC2 인스턴스 프로파일에 연결할 IAM 정책을 생성해야 합니다. 정책에는 S3 on Outposts의 액세스 포인트 Amazon 리소스 이름(ARN)에 대한 액세스 권한이 있어야 합니다. S3 on Outposts용 IAM 정책을 생성하는 방법에 대한 자세한 내용은 [S3 on Outposts로 IAM 설정](S3OutpostsIAM.md) 섹션을 참조하세요.

다음 정책 예제에서는 필요한 권한을 부여하는 방법을 보여줍니다. 정책을 생성한 후에는 [클러스터 생성 및 구성](#configure-cluster) 섹션의 내용대로 정책을 EMR 클러스터를 생성하는 데 사용하는 인스턴스 프로파일 역할에 연결할 수 있습니다. 이 예제를 사용하려면 *`user input placeholders`*를 사용자의 정보로 대체합니다.

```
 1. {
 2. "Version":"2012-10-17",		 	 	  
 3.   "Statement": [
 4.         {
 5.   "Effect": "Allow",
 6.             "Resource": "arn:aws:s3-outposts:us-west-2:111122223333:outpost/op-01ac5d28a6a232904/accesspoint/access-point-name,
 7.             "Action": [
 8.                 "s3-outposts:*"
 9.             ]
10.         }
11.     ]
12.     
13.  }
```

### 클러스터 생성 및 구성
<a name="configure-cluster"></a>

S3 on Outposts를 사용하여 Spark를 실행하는 클러스터를 생성하려면 콘솔에서 다음 단계를 완료하세요.

**S3 on Outposts를 사용하여 Spark를 실행하는 클러스터를 만들려면**

1. [https://console.aws.amazon.com/elasticmapreduce/](https://console.aws.amazon.com/elasticmapreduce/)에서 Amazon EMR 콘솔을 엽니다.

1. 좌측 탐색 창에서 **클러스터**를 선택합니다.

1. **클러스터 생성**을 선택합니다.

   

1. **Amazon EMR 릴리스**의 경우 **emr-7.0.0** 이상을 선택합니다.

1. 애플리케이션 번들의 경우 **Spark 대화형**을 선택합니다. 그런 다음 클러스터에 포함할 다른 지원 애플리케이션을 선택합니다.

1. Amazon S3 on Outposts를 활성화하려면 구성 설정을 입력합니다.

**샘플 구성 설정**  
다음 샘플 구성 설정을 사용하려면 `user input placeholders`를 실제 정보로 대체합니다.

   ```
    1. [
    2.  {
    3.    "Classification": "core-site",
    4.    "Properties": {
    5.      "fs.s3a.bucket.DOC-EXAMPLE-BUCKET.accesspoint.arn": "arn:aws:s3-outposts:us-west-2:111122223333:outpost/op-01ac5d28a6a232904/accesspoint/access-point-name"
    6.      "fs.s3a.committer.name": "magic", 
    7.      "fs.s3a.select.enabled": "false"
    8.     }
    9.   },
   10.   {
   11.     "Classification": "hadoop-env",
   12.     "Configurations": [
   13.       {
   14.         "Classification": "export",
   15.         "Properties": {
   16.           "JAVA_HOME": "/usr/lib/jvm/java-11-amazon-corretto.x86_64" 
   17.           }
   18.        }
   19.      ],
   20.      "Properties": {}
   21.    },
   22.    {
   23.      "Classification": "spark-env",
   24.      "Configurations": [
   25.        {
   26.          "Classification": "export",
   27.          "Properties": {
   28.            "JAVA_HOME": "/usr/lib/jvm/java-11-amazon-corretto.x86_64"
   29.          }
   30.        }
   31.       ],
   32.       "Properties": {}
   33.      },
   34.      {
   35.       "Classification": "spark-defaults",
   36.       "Properties": {
   37.         "spark.executorEnv.JAVA_HOME": "/usr/lib/jvm/java-11-amazon-corretto.x86_64",
   38.         "spark.sql.sources.fastS3PartitionDiscovery.enabled": "false"
   39.       }
   40.      }
   41.   ]
   ```

1. **네트워킹** 섹션에서 AWS Outposts 랙에 있는 Virtual Private Cloud(VPC) 및 서브넷을 선택합니다. Amazon EMR on Outposts에 대한 자세한 내용은 **Amazon EMR 관리 안내서의 [AWS Outposts의 EMR 클러스터](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-outposts.html)를 참조하세요.

1. **Amazon EMR용 EC2 인스턴스 프로필** 섹션에서 [이전에 생성한 권한 정책](#create-permission-policy)이 첨부되어 있는 IAM 역할을 선택합니다.

1. 나머지 클러스터 설정을 구성한 다음 **클러스터 생성**을 선택합니다.

### 구성 개요
<a name="configurations-overview"></a>

다음 표에서는 Amazon EMR과 함께 S3 on Outposts를 사용하는 클러스터를 설정할 때 S3A 구성과 해당 파라미터에 지정할 값을 설명합니다.


| 파라미터 | 기본값 | S3 on Outposts의 필수 값 | 설명 | 
| --- | --- | --- | --- | 
|  `fs.s3a.aws.credentials.provider`  |  지정하지 않으면 S3A는 Outposts 버킷 이름을 가진 리전 버킷에서 S3를 찾습니다.  |  S3 on Outposts 버킷의 액세스 포인트 ARN  |  Amazon S3 on Outposts는 Outposts 버킷에 액세스할 수 있는 유일한 수단으로 Virtual Private Cloud(VPC) 전용 액세스 포인트를 지원합니다.  | 
|  `fs.s3a.committer.name`  | file |  `magic`  |  매직 커미터는 S3 on Outposts에 대해 지원되는 유일한 커미터입니다.  | 
|  `fs.s3a.select.enabled`  |  `TRUE`  |  `FALSE`  | S3 Select는 Outposts에서 지원되지 않습니다. | 
|  `JAVA_HOME`  |  `/usr/lib/jvm/java-8`  |  `/usr/lib/jvm/java-11-amazon-corretto.x86_64`  |  S3A의 S3 on Outposts에는 Java 버전 11이 필요합니다.  | 

다음 표에서는 Amazon EMR과 함께 S3 on Outposts를 사용하는 클러스터를 설정할 때 Spark 구성과 해당 파라미터에 지정할 값을 설명합니다.


| 파라미터 | 기본값 | S3 on Outposts의 필수 값 | 설명 | 
| --- | --- | --- | --- | 
|  `spark.sql.sources.fastS3PartitionDiscovery.enabled`  |  `TRUE`  |  `FALSE`  |  S3 on Outposts는 빠른 파티션을 지원하지 않습니다.  | 
|  `spark.executorEnv.JAVA_HOME`  |  `/usr/lib/jvm/java-8`  |  `/usr/lib/jvm/java-11-amazon-corretto.x86_64`  |  S3A의 S3 on Outposts에는 Java 버전 11이 필요합니다.  | 

### 고려 사항
<a name="considerations"></a>

Amazon EMR을 S3 on Outposts 버킷과 통합하는 경우에는 다음 사항을 고려하세요.
+ Amazon S3 on Outposts는 Amazon EMR 버전 7.0.0 이상에서 지원됩니다.
+ S3 on Outposts를 Amazon EMR과 함께 사용하기 위해서는 S3A 커넥터가 있어야 합니다. S3 on Outposts 버킷과 상호 작용하는 데 필요한 기능은 S3A에만 있습니다. S3A 커넥터 설정 정보는 [사전 조건](#s3a-outposts-prerequisites)을 참조하세요.
+ Amazon S3 on Outposts는 Amazon EMR을 통해 Amazon S3 관리형 키(SSE-S3)를 사용한 서버 측 암호화만 지원합니다. 자세한 내용은 [S3 on Outposts의 데이터 암호화](s3-outposts-data-encryption.md) 섹션을 참조하세요.
+ Amazon S3 on Outposts는 S3A FileOutputCommitter를 사용한 쓰기를 지원하지 않습니다. S3 on Outposts에서 S3A FileOutputCommitter를 사용하여 쓰면 invalidStorageClass: 지정한 스토리지 클래스가 유효하지 않습니다. 오류가 발생합니다.
+ Amazon S3 on Outposts는 Amazon EMR Serverless 또는 Amazon EMR on EKS에서 지원되지 않습니다.
+ Amazon EMR 로그는 사용자가 선택한 리전 Amazon S3 위치에 저장되며 S3 on Outposts 버킷에 로컬로 저장되지는 않습니다.

# 권한 부여 및 인증 캐시
<a name="s3-outposts-auth-cache"></a>

S3 on Outposts는 인증 및 권한 부여 데이터를 Outposts 랙에 로컬로 안전하게 캐시합니다. 캐시는 요청이 있을 때마다 상위 AWS 리전으로의 왕복 이동을 제거합니다. 이렇게 하면 네트워크 왕복으로 인해 발생하는 변동성이 없어집니다. S3 on Outposts의 인증 및 권한 부여 캐시를 사용하면 Outposts와 AWS 리전 간의 연결 지연 시간에 구애받지 않고 일관된 지연 시간을 확보할 수 있습니다.

S3 on Outposts API 요청을 수행하면 인증 및 권한 부여 데이터가 안전하게 캐시됩니다. 그런 다음, 캐시된 데이터를 사용하여 후속 S3 객체 API 요청을 인증합니다. S3 on Outposts는 요청이 Signature Version 4A(SigV4A)를 사용하여 서명된 경우에만 인증 및 권한 부여 데이터를 캐시합니다. 캐시는 S3 on Outposts 서비스 내의 Outposts에 로컬로 저장됩니다. S3 API 요청을 하면 비동기적으로 새로 고쳐집니다. 캐시는 암호화되며 Outposts에는 일반 텍스트 암호화 키가 저장되지 않습니다.

Outpost가 AWS 리전에 연결된 경우 캐시는 최대 10분 동안 유효합니다. S3 on Outposts API 요청을 수행하면 최신 정책이 사용되도록 비동기적으로 새로 고쳐집니다. Outpost와 AWS 리전의 연결이 끊긴 경우 캐시는 최대 12시간 동안 유효합니다.

## 권한 부여 및 인증 캐시 구성
<a name="config-auth-cache"></a>

S3 on Outposts는 SigV4A 알고리즘으로 서명된 요청에 대한 인증 및 권한 부여 데이터를 자동으로 캐시합니다. 자세한 내용은 **AWS Identity and Access Management 사용 설명서의 [AWS API 요청에 서명](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-signing.html)을 참조하세요. SigV4A 알고리즘은 AWS SDK의 최신 버전에서 사용 가능합니다. [AWS 공용 런타임(CRT) 라이브러리](https://docs.aws.amazon.com/sdkref/latest/guide/common-runtime.html)의 종속성을 통해 얻을 수 있습니다.

최신 버전의 AWS SDK를 사용하고 최신 버전의 CRT를 설치해야 합니다. 예를 들어, `pip install awscrt`를 실행하여 Boto3로 최신 버전의 CRT를 얻을 수 있습니다.

S3 on Outposts는 SigV4 알고리즘으로 서명된 요청에 대한 인증 및 권한 부여 데이터를 캐시하지 않습니다.

## SigV4A 서명 검증
<a name="validate-SigV4A"></a>

요청을 SigV4A로 서명했는지 검증하는 데 AWS CloudTrail을 사용할 수 있습니다. S3 on Outposts를 위해 CloudTrail을 설정하는 방법에 대한 자세한 내용은 [AWS CloudTrail 로그로 S3 on Outposts 모니터링](S3OutpostsCloudtrail.md) 섹션을 참조하세요.

CloudTrail을 구성한 후에는 CloudTrail 로그의 `SignatureVersion` 필드에서 요청이 어떻게 서명되었는지 확인할 수 있습니다. SigV4A로 서명된 요청은 `SignatureVersion`이 `AWS4-ECDSA-P256-SHA256`으로 설정됩니다. SigV4로 서명된 요청은 `SignatureVersion`이 `AWS4-HMAC-SHA256`으로 설정됩니다.