IBM Cloud Docs
버킷 비우기

버킷 비우기

이 개요는 각 항목을 순차적으로 삭제하기 위해 IBM Cloud® Object Storage 의 인스턴스 내에 있는 버킷의 모든 항목 목록에 액세스하는 데 필요한 단계에 초점을 맞춥니다.

버킷을 비우는 프로세스는 버킷을 삭제하려면 비어 있어야 하므로 IBM Cloud Object Storage 의 인스턴스에서 버킷을 삭제해야 하는 모든 사용자에게 익숙합니다. 항목을 삭제하지만 모든 오브젝트를 개별적으로 삭제하지 않으려는 다른 이유가 있을 수 있습니다. 지원되는 SDK에 대한 이 코드 패턴을 사용하면 구성을 정의하고 클라이언트를 작성한 후 해당 클라이언트와 연결하여 식별된 버킷의 모든 항목 목록을 가져와서 삭제할 수 있습니다.

버전화가 사용 가능한 경우 만기 규칙은 마커 삭제 를 작성합니다.

스크립트에 신임 정보를 넣지 않는 것이 좋습니다. 이 예제는 테스트 및 교육용이며, 사용자의 특정 설정은 우수 사례 및 개발자 안내 로 알려야 합니다.

시작하기 전에

SDK 다운로드 및 설치에 대한 특정 지시사항은 Python, Node.js, JavaGo 에 사용 가능합니다. 또한 명령행 지시사항 (CLI) 및 CLI 클라이언트에 대해 작업할 때 AWS 호환성, Miniorclone 에 관한 Object Storage 관련 정보를 확인하십시오.

이 코드 패턴의 경우 다음이 필요합니다.

콘솔 사용

예제에 도달하기 전에 IBM Cloud 콘솔에서 GUI를 통해 버킷 자체의 만기 규칙을 사용하여 버킷을 비우는 한 가지 방법이 있습니다. 자세한 정보는 만기 규칙으로 시간이 경과된(stale)데이터 삭제 에 대한 문서를 참조하십시오.

Object Storage 로그인한 후 스토리지 인스턴스를 선택합니다. 그런 다음 버킷 목록에서 버킷을 선택하십시오. 항목을 삭제하는 규칙을 설정하려면 탐색 메뉴에서 구성을 선택하고 만료 규칙 섹션에서 규칙 추가를 클릭합니다. 1일 후 모든 항목을 삭제하려면 일 수를 '1'로 설정하십시오.

항목을 삭제하는 만료 규칙 추가
'' '
'

규칙 완료 프로세스는 최대 24시간이 소요될 수 있으며 설정된 스케줄에 따라 수행됩니다. 이 기술을 적용할 때 이 점을 고려하십시오.

CLI 클라이언트 예제

사용자가 Object Storage 를 최대한 활용하는 데 사용할 수 있는 많은 도구가 있으며 다음 CLI 클라이언트는 버킷을 비우는 간단한 방법을 제공합니다.

CLI 클라이언트가 구성되어 작동되면 클라이언트 애플리케이션 또는 명령행을 사용하기 위한 샘플 지시사항이 제공됩니다.

rclone

' rclone ' 도구는 일반적으로 디렉터리를 동기화하고 스토리지 플랫폼 간에 데이터를 마이그레이션하는 데 사용됩니다. rclone 사용 의 문서에서 자세히 학습할 수 있습니다.

rclone purge {remote}:{path} [flags]

Minio 예제

오픈 소스 Minio 클라이언트를 사용하면 IBM Cloud® Object Storage과 함께 UNIX 유사 명령 (ls, cp, cat 등) 을 사용할 수 있습니다. 자세한 정보는 Minio 사용 을 참조하십시오.

mc rm --recursive --force {instance-alias}/{bucket-name}

AWS 예제

AWS 의 공식 명령행 인터페이스는 IBM Cloud Object Storage S3 API와 호환 가능하며 AWS CLI를 사용 하는 방법에 대해 자세히 알 수 있습니다.

aws s3 rm s3://{bucket-name} --recursive

코드 예

전체 디렉토리를 삭제하거나 버킷의 모든 컨텐츠를 제거하면 한 번에 하나씩 각 오브젝트를 삭제하는 데 시간이 걸릴 수 있습니다. 한 번에 하나의 항목을 삭제하는 기능을 활용하면 삭제 전에 모든 항목의 목록을 수집하여 시간과 노력을 절약할 수 있습니다.

주제 자체가 삭제의 위험을 지적합니다. 데이터가 유실 됩니다. 물론, 그것이 목표일 때에는 목표로 하는 삭제만 발생하도록 주의해야 합니다. 인스턴스, 버킷 이름 및 지정해야 하는 접두부 또는 경로를 확인하고 다시 확인하십시오.

개요

이 연습의 코드 패턴은 각 오브젝트를 삭제하기 위해 항목 목록을 수집할 목적으로 클라이언트를 작성하기 전에 클라이언트를 구성합니다.

이 연습의 코드 패턴은 각 오브젝트를 삭제하기 위해 항목 목록을 수집할 목적으로 클라이언트를 작성하기 전에 클라이언트를 구성합니다.

이 연습의 코드 패턴은 각 오브젝트를 삭제하기 위해 항목 목록을 수집할 목적으로 클라이언트를 작성하기 전에 클라이언트를 구성합니다.

이 연습의 코드 패턴은 각 오브젝트를 삭제하기 위해 항목 목록을 수집할 목적으로 클라이언트를 작성하기 전에 클라이언트를 구성합니다.

const myCOS = require('ibm-cos-sdk');

var config = {
    endpoint: 's3.us-geo.cloud-object-storage.appdomain.cloud',
    apiKeyId: 'd-2-DO-NOT-USEevplExampleo_t3ZTCJO',
    ibmAuthEndpoint: 'https://iam.cloud.ibm.com/identity/token',
    serviceInstanceId: 'crn:v1:bluemix:public:cloud-object-storage:global:a/SAMPLE253abf6e65dca920c9d58126b:3f656f43-5c2a-941e-b128-DO-NOT-USE::',
};

var cosClient = new myCOS.S3(config);

function logDone() {
    console.log('COMPLETE!\n');
}

function logError(e) {
    console.log(`ERROR: ${e.code} - ${e.message}\n`);
}

// Retrieve the list of contents from a bucket for deletion
function deleteContents(bucketName) {
    var returnArr = new Array();

    console.log(`Retrieving bucket contents from: ${bucketName}\n`);
    return cosClient.listObjects(
        {Bucket: bucketName},
    ).promise()
    .then((data) => {
        if (data != null && data.Contents != null) {
            for (var i = 0; i < data.Contents.length; i++) {
                returnArr.push(data.Contents[i].Key);
                var itemKey = data.Contents[i].Key;
                var itemSize = data.Contents[i].Size;
                console.log(`Item: ${itemKey} (${itemSize} bytes).\n`)
            }
            deleteItem(bucketName, itemName);
            logDone();
        }
    })
    .catch(logError);
}

// Delete item
function deleteItem(bucketName, itemName) {
    console.log(`Deleting item: ${itemName}`);
    return cosClient.deleteObject({
        Bucket: bucketName,
        Key: itemName
    }).promise()
    .then(() =>{
        console.log(`Item: ${itemName} deleted!`);
    })
    .catch(logError);
}

function main() {
    try {
        var BucketName = "<BUCKET_NAME>";

        deleteContents(BucketName);
    }
    catch(ex) {
        logError(ex);
    }
}

main();
import ibm_boto3
from ibm_botocore.client import Config, ClientError

# Constants for IBM COS values
COS_ENDPOINT = "<endpoint>" # Current list avaiable at https://control.cloud-object-storage.cloud.ibm.com/v2/endpoints
COS_API_KEY_ID = "<api-key>" # eg "W00YiRnLW4a3fTjMB-odB-2ySfTrFBIQQWanc--P3byk"
COS_AUTH_ENDPOINT = "https://iam.cloud.ibm.com/identity/token"
COS_RESOURCE_CRN = "<resource-instance-id>" # eg "crn:v1:bluemix:public:cloud-object-storage:global:a/3bf0d9003abfb5d29761c3e97696b71c:d6f04d83-6c4f-4a62-a165-696756d63903::"

# Create resource
cos = ibm_boto3.resource("s3",
    ibm_api_key_id=COS_API_KEY_ID,
    ibm_service_instance_id=COS_RESOURCE_CRN,
    ibm_auth_endpoint=COS_AUTH_ENDPOINT,
    config=Config(signature_version="oauth"),
    endpoint_url=COS_ENDPOINT
)

def get_bucket_contents(bucket_name, max_keys):
    print("Retrieving bucket contents from: {0}".format(bucket_name))
    returnArray = []
    try:
        files = cos.Bucket(bucket_name).objects.all()
        for file in files:
            print("Item: {0} ({1} bytes).".format(file["Key"], file["Size"]))
            returnArray.append(file["Key"])

    except ClientError as be:
        print("CLIENT ERROR: {0}\n".format(be))
    except Exception as e:
        print("Unable to retrieve bucket contents: {0}".format(e))

    return returnArray

def delete_item(bucket_name, item_name):
    print("Deleting item: {0}".format(item_name))
    try:
        cos.Object(bucket_name, item_name).delete()
        print("Item: {0} deleted!".format(item_name))
    except ClientError as be:
        print("CLIENT ERROR: {0}\n".format(be))
    except Exception as e:
        print("Unable to delete item: {0}".format(e))

def main():
    bucket = "<bucket_name>"
    deleteListArray = get_bucket_contents(bucket, 1000)
    for item_name in deleteListArray:
        delete_item(bucket, item_name)

main()
package com.cos;

    import java.sql.Timestamp;
    import java.util.List;

    import com.ibm.cloud.objectstorage.ClientConfiguration;
    import com.ibm.cloud.objectstorage.SDKGlobalConfiguration;
    import com.ibm.cloud.objectstorage.auth.AWSCredentials;
    import com.ibm.cloud.objectstorage.auth.AWSStaticCredentialsProvider;
    import com.ibm.cloud.objectstorage.auth.BasicAWSCredentials;
    import com.ibm.cloud.objectstorage.client.builder.AwsClientBuilder.EndpointConfiguration;
    import com.ibm.cloud.objectstorage.services.s3.AmazonS3;
    import com.ibm.cloud.objectstorage.services.s3.AmazonS3ClientBuilder;
    import com.ibm.cloud.objectstorage.services.s3.model.Bucket;
    import com.ibm.cloud.objectstorage.services.s3.model.ListObjectsRequest;
    import com.ibm.cloud.objectstorage.services.s3.model.ListObjectsV2Request;
    import com.ibm.cloud.objectstorage.services.s3.model.ListObjectsV2Result;
    import com.ibm.cloud.objectstorage.services.s3.model.ObjectListing;
    import com.ibm.cloud.objectstorage.services.s3.model.S3ObjectSummary;
    import com.ibm.cloud.objectstorage.oauth.BasicIBMOAuthCredentials;

    public class CosDeleteMultipleItems
    {

        private static AmazonS3 _cosClient;

        /**
         * @param args
         */
        public static void main(String[] args)
        {

            SDKGlobalConfiguration.IAM_ENDPOINT = "https://iam.cloud.ibm.com/identity/token";

            String bucketName = "<BUCKET_NAME>";  // eg my-unique-bucket-name
            String newBucketName = "<NEW_BUCKET_NAME>"; // eg my-other-unique-bucket-name
            String api_key = "<API_KEY>"; // eg "W00YiRnLW4k3fTjMB-oiB-2ySfTrFBIQQWanc--P3byk"
            String service_instance_id = "<SERVICE_INSTANCE_ID"; // eg "crn:v1:bluemix:public:cloud-object-storage:global:a/3bf0d9003abfb5d29761c3e97696b71c:d6f04d83-6c4f-4a62-a165-696756d63903::"
            String endpoint_url = "https://s3.us.cloud-object-storage.appdomain.cloud"; // this could be any service endpoint

            String storageClass = "us-geo";
            String location = "us";

            _cosClient = createClient(api_key, service_instance_id, endpoint_url, location);

            contentsForDeletion(bucketName, 1000);

            for(Int deletedItem: itemsForDeletion) {
                deleteItem(bucketName, deletedItem.getKey());
                System.out.printf("Deleted item: %s\n", deletedItem.getKey());
            }
        }

        /**
         * @param api_key
         * @param service_instance_id
         * @param endpoint_url
         * @param location
         * @return AmazonS3
         */
        public static AmazonS3 createClient(String api_key, String service_instance_id, String endpoint_url, String location)
        {
            AWSCredentials credentials;
            credentials = new BasicIBMOAuthCredentials(api_key, service_instance_id);

            ClientConfiguration clientConfig = new ClientConfiguration().withRequestTimeout(5000);
            clientConfig.setUseTcpKeepAlive(true);

            AmazonS3 cosClient = AmazonS3ClientBuilder.standard().withCredentials(new AWSStaticCredentialsProvider(credentials))
                    .withEndpointConfiguration(new EndpointConfiguration(endpoint_url, location)).withPathStyleAccessEnabled(true)
                    .withClientConfiguration(clientConfig).build();
            return cosClient;
        }

        public static List contentsForDeletion(String bucketName, int maxKeys) {
            System.out.printf("Retrieving bucket contents (V2) from: %s\n", bucketName);

            boolean moreResults = true;
            String nextToken = "";

            while (moreResults) {
                ListObjectsV2Request request = new ListObjectsV2Request()
                    .withBucketName(bucketName)
                    .withMaxKeys(maxKeys)
                    .withContinuationToken(nextToken);

                ListObjectsV2Result result = _cosClient.listObjectsV2(request);
                for(S3ObjectSummary objectSummary : result.getObjectSummaries()) {
                    System.out.printf("Item: %s (%s bytes)\n", objectSummary.getKey(), objectSummary.getSize());
                    deleteItem(bucketName, objectSummary.getKey());
                }

                if (result.isTruncated()) {
                    nextToken = result.getNextContinuationToken();
                    System.out.println("...More results in next batch!\n");
                }
                else {
                    nextToken = "";
                    moreResults = false;
                }
            }
            System.out.println("...No more results!");
        }

        public static void deleteItem(String bucketName, String itemName) {
            System.out.printf("Deleting item: %s\n", itemName);
            _cosClient.deleteObject(bucketName, itemName);
            System.out.printf("Item: %s deleted!\n", itemName);
        }

    }
import (
    "github.com/IBM/ibm-cos-sdk-go/aws/credentials/ibmiam"
    "github.com/IBM/ibm-cos-sdk-go/aws"
    "github.com/IBM/ibm-cos-sdk-go/aws/session"
    "github.com/IBM/ibm-cos-sdk-go/service/s3"
)

// Constants for IBM COS values
const (
    apiKey            = "<API_KEY>"  // eg "0viPHOY7LbLNa9eLftrtHPpTjoGv6hbLD1QalRXikliJ"
    serviceInstanceID = "<RESOURCE_INSTANCE_ID>" // "crn:v1:bluemix:public:cloud-object-storage:global:a/<CREDENTIAL_ID_AS_GENERATED>:<SERVICE_ID_AS_GENERATED>::"
    authEndpoint      = "https://iam.cloud.ibm.com/identity/token"
    serviceEndpoint   = "<SERVICE_ENDPOINT>" // eg "https://s3.us.cloud-object-storage.appdomain.cloud"
    bucketLocation    = "<LOCATION>" // eg "us"
)

// Create config
conf := aws.NewConfig().
    WithRegion("us-standard").
    WithEndpoint(serviceEndpoint).
    WithCredentials(ibmiam.NewStaticCredentials(aws.NewConfig(), authEndpoint, apiKey, serviceInstanceID)).
    WithS3ForcePathStyle(true)

func main() {

    // Create client
    sess := session.Must(session.NewSession())
    client := s3.New(sess, conf)

    // Bucket Names
    Bucket := "<BUCKET_NAME>"
    Input := &s3.ListObjectsV2Input{
            Bucket: aws.String(Bucket),
        }

    res, _ := client.ListObjectsV2(Input)

    for _, item := range res.Contents {
        input := &s3.DeleteObjectInput{
                Bucket: aws.String(Bucket),
                Key:    aws.String(*item.Key),
            }
        d, _ := client.DeleteObject(input)
        fmt.Println(d)
    }
}

다음 단계

이 개요에서 다루는 도구의 새로운 기능 및 기존 기능을 활용하는 방법은 다음 사이트에서 자세히 설명할 수 있습니다. IBM Cloud 플랫폼.