Hyperdisk Storage Pool 만들기

---

Hyperdisk Storage Pool은 Hyperdisk 블록 스토리지를 집계하여 관리하는 데 도움이 되는 새로운 블록 스토리지 리소스입니다. Hyperdisk Storage Pool은 Hyperdisk Throughput Storage Pool 및 Hyperdisk Balanced Storage Pool 변형에서 사용할 수 있습니다.

스토리지 풀을 만들 때 다음 속성을 지정해야 합니다.

• 영역
• 스토리지 풀 유형
• 용량 프로비저닝 유형
• 풀에서 프로비저닝된 용량
• 성능 프로비저닝 유형
• 풀에서 프로비저닝된 IOPS 및 처리량

Hyperdisk Storage Pool에서 표준 용량, 고급 용량, 표준 성능 또는 고급 성능 프로비저닝 유형을 사용할 수 있습니다.

• 표준 용량: 스토리지 풀에 생성된 각 디스크에 프로비저닝된 용량이 스토리지 풀의 프로비저닝된 총 용량에서 차감됩니다.
• 고급 용량: 스토리지 풀에서 씬 프로비저닝 및 데이터 감소의 이점을 누릴 수 있습니다. 실제로 쓰여진 데이터의 양만 스토리지 풀의 프로비저닝된 총 용량에서 차감됩니다.
• 표준 성능: 스토리지 풀에 생성된 각 디스크에 프로비저닝된 성능이 스토리지 풀의 프로비저닝된 총 성능에서 차감됩니다.
• 고급 성능: 각 디스크에 프로비저닝된 성능이 씬 프로비저닝의 이점을 누립니다. 디스크에서 사용하는 성능 양만 스토리지 풀의 프로비저닝된 총 성능에서 차감됩니다.

  시작하기 전에

  • 아직 인증을 설정하지 않았다면 설정합니다. 인증은 Google Cloud 서비스 및 API에 액세스하기 위해 ID를 확인하는 프로세스입니다. 로컬 개발 환경에서 코드 또는 샘플을 실행하려면 다음과 같이 Compute Engine에 인증하면 됩니다.
    

    Select the tab for how you plan to use the samples on this page:

    Console

    When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

    gcloud

    1. Install the Google Cloud CLI, then initialize it by running the following command:

       gcloud init

       Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
    2. Set a default region and zone.

    Go

    로컬 개발 환경에서 이 페이지의 Go 샘플을 사용하려면 gcloud CLI를 설치 및 초기화한 다음 사용자 인증 정보로 애플리케이션 기본 사용자 인증 정보를 설정하세요.

    1. Install the Google Cloud CLI.

    2. To initialize the gcloud CLI, run the following command:

       gcloud init

    3. If you're using a local shell, then create local authentication credentials for your user account:

       gcloud auth application-default login

       You don't need to do this if you're using Cloud Shell.

    자세한 내용은 다음을 참조하세요: Set up authentication for a local development environment.

    Java

    로컬 개발 환경에서 이 페이지의 Java 샘플을 사용하려면 gcloud CLI를 설치 및 초기화한 다음 사용자 인증 정보로 애플리케이션 기본 사용자 인증 정보를 설정하세요.

    1. Install the Google Cloud CLI.

    2. To initialize the gcloud CLI, run the following command:

       gcloud init

    3. If you're using a local shell, then create local authentication credentials for your user account:

       gcloud auth application-default login

       You don't need to do this if you're using Cloud Shell.

    자세한 내용은 다음을 참조하세요: Set up authentication for a local development environment.

    Node.js

    로컬 개발 환경에서 이 페이지의 Node.js 샘플을 사용하려면 gcloud CLI를 설치 및 초기화한 다음 사용자 인증 정보로 애플리케이션 기본 사용자 인증 정보를 설정하세요.

    1. Install the Google Cloud CLI.

    2. To initialize the gcloud CLI, run the following command:

       gcloud init

    3. If you're using a local shell, then create local authentication credentials for your user account:

       gcloud auth application-default login

       You don't need to do this if you're using Cloud Shell.

    자세한 내용은 다음을 참조하세요: Set up authentication for a local development environment.

    REST

    로컬 개발 환경에서 이 페이지의 REST API 샘플을 사용하려면 gcloud CLI에 제공한 사용자 인증 정보를 사용합니다.

    Install the Google Cloud CLI, then initialize it by running the following command:

    gcloud init

    자세한 내용은 Google Cloud 인증 문서의 REST 사용을 위한 인증을 참고하세요.

  필수 역할 및 권한

  스토리지 풀을 만드는 데 필요한 권한을 얻으려면 관리자에게 프로젝트에 대한 다음 IAM 역할을 부여해 달라고 요청하세요.

  • Compute 인스턴스 관리자(v1)(roles/compute.instanceAdmin.v1)
  • 서비스 계정으로 실행할 수 있는 VM 인스턴스에 연결: 서비스 계정 사용자(v1)(roles/iam.serviceAccountUser 역할)

  역할 부여에 대한 자세한 내용은 프로젝트, 폴더, 조직에 대한 액세스 관리를 참조하세요.

  이러한 사전 정의된 역할에는 스토리지 풀을 만드는 데 필요한 권한이 포함되어 있습니다. 필요한 정확한 권한을 보려면 필수 권한 섹션을 펼치세요.

  필수 권한

  스토리지 풀을 만들려면 다음 권한이 필요합니다.

  • 프로젝트에 대한 compute.storagePools.create 권한
  • 프로젝트에 대한 compute.storagePools.setLabels 권한

  커스텀 역할이나 다른 사전 정의된 역할을 사용하여 이 권한을 부여받을 수도 있습니다.

  제한사항

  하이퍼디스크 스토리지 풀을 만들 때는 다음 제한사항에 유의하세요.

  리소스 한도:

  • 최대 1PiB의 프로비저닝된 용량의 하이퍼디스크 스토리지 풀을 만들 수 있습니다.
  • 시간당 최대 5개의 스토리지 풀을 만들 수 있습니다.
  • 하루에 최대 10개의 스토리지 풀을 만들 수 있습니다.
  • 프로젝트별로 최대 10개의 스토리지 풀을 만들 수 있습니다.
  • 풀의 프로비저닝 모델은 변경할 수 없습니다. 표준 용량 스토리지 풀을 고급 용량 스토리지 풀로 변경하거나 고급 성능 스토리지 풀을 표준 성능 스토리지 풀로 변경할 수 없습니다.
  • 스토리지 풀은 영역별 리소스입니다.
  • 스토리지 풀에 최대 1,000개의 디스크를 만들 수 있습니다.
  • Compute Engine에서만 하이퍼디스크 스토리지 풀을 사용할 수 있습니다. Cloud SQL 인스턴스는 하이퍼디스크 스토리지 풀을 사용할 수 없습니다.
  • 24시간 내에 최대 2회까지 스토리지 풀의 프로비저닝된 용량 또는 성능을 변경할 수 있습니다.

  스토리지 풀의 디스크 한도:

  • 동일한 프로젝트 및 영역의 새 디스크만 스토리지 풀에 만들 수 있습니다.
  • 디스크를 스토리지 풀 안팎으로 이동할 수 없습니다. 디스크를 스토리지 풀 안팎으로 이동하려면 스냅샷에서 디스크를 다시 만들어야 합니다. 자세한 내용은 디스크 유형 변경을 참조하세요.
  • 스토리지 풀에서 부팅 디스크를 만들려면 Hyperdisk Balanced Storage Pool을 사용해야 합니다.
  • 스토리지 풀은 리전 디스크를 지원하지 않습니다.
  • 스토리지 풀의 디스크를 클론하거나, 인스턴스 스냅샷을 만들거나, 영구 디스크 비동기 복제를 구성할 수 없습니다.
  • 스토리지 풀의 Hyperdisk Balanced 디스크는 여러 컴퓨팅 인스턴스에 연결할 수 없습니다.

  용량 범위 및 프로비저닝된 성능 한도

  스토리지 풀을 만들 때 프로비저닝된 용량, IOPS, 처리량에는 스토리지 풀 제한사항에 설명된 한도가 적용됩니다.

  Hyperdisk Storage Pool 만들기

  새 Hyperdisk Storage Pool을 만들려면 Google Cloud 콘솔, Google Cloud CLI 또는 REST를 사용합니다.

  콘솔

  1. Google Cloud 콘솔에서 스토리지 풀 만들기 페이지로 이동합니다.
     스토리지 풀 만들기 페이지로 이동
  2. 이름 필드에 스토리지 풀의 고유한 이름을 입력합니다.
  3. 선택사항: 설명 필드에 스토리지 풀에 대한 설명을 입력합니다.
  4. 스토리지 풀을 만들 리전 및 영역을 선택합니다.
  5. 스토리지 풀 유형의 값을 선택합니다.

  6. 용량 유형 필드에서 프로비저닝 유형을 선택하고 스토리지 풀 용량 필드에서 스토리지 풀에 프로비저닝할 용량을 지정합니다. 10TiB~1PiB의 크기를 지정할 수 있습니다.

     대용량 스토리지 풀을 만들려면 할당량 상향을 요청해야 할 수 있습니다.

  7. 성능 유형 필드에서 프로비저닝 유형을 선택합니다.

  8. Hyperdisk Balanced Storage Pool의 경우 프로비저닝된 IOPS 필드에 스토리지 풀에 대해 프로비저닝할 IOPS를 입력합니다.

  9. Hyperdisk Throughput Storage Pool 또는 Hyperdisk Balanced Storage Pool의 경우 프로비저닝된 처리량 필드에 스토리지 풀에 대해 프로비저닝할 처리량을 입력합니다.

  10. 제출을 클릭하여 스토리지 풀을 만듭니다.

  gcloud

  Hyperdisk Storage Pool을 만들려면 gcloud compute storage-pools create 명령어를 사용합니다.

  gcloud compute storage-pools create NAME  \
      --zone=ZONE   \
      --storage-pool-type=STORAGE_POOL_TYPE   \
      --capacity-provisioning-type=CAPACITY_TYPE \
      --provisioned-capacity=POOL_CAPACITY   \
      --performance-provisioning-type=PERFORMANCE_TYPE \
      --provisioned-iops=IOPS   \
      --provisioned-throughput=THROUGHPUT   \
      --description=DESCRIPTION
  

  다음을 바꿉니다.

  • NAME: 고유한 스토리지 풀 이름입니다.
  • ZONE: 스토리지 풀을 만들 영역입니다(예: us-central1-a).
  • STORAGE_POOL_TYPE: 스토리지 풀에 저장할 디스크의 유형입니다. 허용되는 값은 hyperdisk-throughput 및 hyperdisk-balanced입니다.
  • CAPACITY_TYPE: 선택사항: 스토리지 풀의 용량 프로비저닝 유형입니다. 허용되는 값은 advanced 및 standard입니다. 지정하지 않으면 advanced 값이 사용됩니다.
  • POOL_CAPACITY: 새 스토리지 풀을 프로비저닝하기 위한 총 용량이며, 기본적으로 GiB로 지정됩니다.
  • PERFORMANCE_TYPE: 선택사항인 스토리지 풀의 성능 프로비저닝 유형입니다. 허용되는 값은 advanced 및 standard입니다. 지정하지 않으면 advanced 값이 사용됩니다.
  • IOPS: 스토리지 풀에 프로비저닝할 IOPS입니다. 이 플래그는 Hyperdisk Balanced Storage Pool에만 사용할 수 있습니다.
  • THROUGHPUT: 스토리지 풀에 프로비저닝할 처리량(MBps)입니다.
  • DESCRIPTION: 선택사항. 스토리지 풀을 설명하는 텍스트 문자열입니다.

  REST

  storagePools.insert 메서드를 사용하여 Hyperdisk Storage Pool을 만드는 POST 요청을 작성합니다.

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/storagePools
  
  {
      "name": "NAME",
      "description": "DESCRIPTION",
      "poolProvisionedCapacityGb": "POOL_CAPACITY",
      "storagePoolType": "projects/PROJECT_ID/zones/ZONE/storagePoolTypes/STORAGE_POOL_TYPE",
      "poolProvisionedIops": "IOPS",
      "poolProvisionedThroughput": "THROUGHPUT",
      "capacityProvisioningType": "CAPACITY_TYPE",
      "performanceProvisioningType": "PERFORMANCE_TYPE"
  }
  

  다음을 바꿉니다.

  • PROJECT_ID: 프로젝트 ID
  • ZONE: 스토리지 풀을 만들 영역입니다(예: us-central1-a).
  • NAME: 스토리지 풀의 고유한 이름입니다.
  • DESCRIPTION: 선택사항. 스토리지 풀을 설명하는 텍스트 문자열입니다.
  • POOL_CAPACITY: 새 스토리지 풀을 프로비저닝하기 위한 총 용량이며, 기본적으로 GiB로 지정됩니다.
  • STORAGE_POOL_TYPE: 스토리지 풀에 저장할 디스크의 유형입니다. 허용되는 값은 hyperdisk-throughput 및 hyperdisk-balanced입니다.
  • IOPS: 선택사항: 스토리지 풀에 프로비저닝할 IOPS입니다. 이 플래그는 Hyperdisk Balanced Storage Pool에만 사용할 수 있습니다.
  • THROUGHPUT: 선택사항: 스토리지 풀에 프로비저닝할 처리량(MBps)입니다.
  • CAPACITY_TYPE: 선택사항: 스토리지 풀의 용량 프로비저닝 유형입니다. 허용되는 값은 advanced 및 standard입니다. 지정하지 않으면 advanced 값이 사용됩니다.
  • PERFORMANCE_TYPE: 선택사항인 스토리지 풀의 성능 프로비저닝 유형입니다. 허용되는 값은 advanced 및 standard입니다. 지정하지 않으면 advanced 값이 사용됩니다.

  Go

  
  // createHyperdiskStoragePool creates a new Hyperdisk storage pool in the specified project and zone.
  func createHyperdiskStoragePool(w io.Writer, projectId, zone, storagePoolName, storagePoolType string) error {
  	// projectID := "your_project_id"
  	// zone := "europe-west4-b"
  	// storagePoolName := "your_storage_pool_name"
  	// storagePoolType := "projects/**your_project_id**/zones/europe-west4-b/diskTypes/hyperdisk-balanced"
  
  	ctx := context.Background()
  	client, err := compute.NewStoragePoolsRESTClient(ctx)
  	if err != nil {
  		return fmt.Errorf("NewStoragePoolsRESTClient: %v", err)
  	}
  	defer client.Close()
  
  	// Create the storage pool resource
  	resource := &computepb.StoragePool{
  		Name:                        proto.String(storagePoolName),
  		Zone:                        proto.String(zone),
  		StoragePoolType:             proto.String(storagePoolType),
  		CapacityProvisioningType:    proto.String("advanced"),
  		PerformanceProvisioningType: proto.String("advanced"),
  		PoolProvisionedCapacityGb:   proto.Int64(10240),
  		PoolProvisionedIops:         proto.Int64(10000),
  		PoolProvisionedThroughput:   proto.Int64(1024),
  	}
  
  	// Create the insert storage pool request
  	req := &computepb.InsertStoragePoolRequest{
  		Project:             projectId,
  		Zone:                zone,
  		StoragePoolResource: resource,
  	}
  
  	// Send the insert storage pool request
  	op, err := client.Insert(ctx, req)
  	if err != nil {
  		return fmt.Errorf("Insert storage pool request failed: %v", err)
  	}
  
  	// Wait for the insert storage pool operation to complete
  	if err = op.Wait(ctx); err != nil {
  		return fmt.Errorf("unable to wait for the operation: %w", err)
  	}
  
  	// Retrieve and return the created storage pool
  	storagePool, err := client.Get(ctx, &computepb.GetStoragePoolRequest{
  		Project:     projectId,
  		Zone:        zone,
  		StoragePool: storagePoolName,
  	})
  	if err != nil {
  		return fmt.Errorf("Get storage pool request failed: %v", err)
  	}
  
  	fmt.Fprintf(w, "Hyperdisk Storage Pool created: %v\n", storagePool.GetName())
  	return nil
  }
  

  자바

  
  import com.google.cloud.compute.v1.InsertStoragePoolRequest;
  import com.google.cloud.compute.v1.Operation;
  import com.google.cloud.compute.v1.StoragePool;
  import com.google.cloud.compute.v1.StoragePoolsClient;
  import java.io.IOException;
  import java.util.concurrent.ExecutionException;
  import java.util.concurrent.TimeUnit;
  import java.util.concurrent.TimeoutException;
  
  public class CreateHyperdiskStoragePool {
    public static void main(String[] args)
            throws IOException, ExecutionException, InterruptedException, TimeoutException {
      // TODO(developer): Replace these variables before running the sample.
      // Project ID or project number of the Google Cloud project you want to use.
      String projectId = "YOUR_PROJECT_ID";
      // Name of the zone in which you want to create the storagePool.
      String zone = "europe-central2-b";
      // Name of the storagePool you want to create.
      String storagePoolName = "YOUR_STORAGE_POOL_NAME";
      // The type of disk you want to create. This value uses the following format:
      // "projects/%s/zones/%s/storagePoolTypes/hyperdisk-throughput|hyperdisk-balanced"
      String storagePoolType = "hyperdisk-balanced";
      // Optional: the capacity provisioning type of the storage pool.
      // The allowed values are advanced and standard. If not specified, the value advanced is used.
      String capacityProvisioningType = "advanced";
      // The total capacity to provision for the new storage pool, specified in GiB by default.
      long provisionedCapacity = 128;
      // the IOPS to provision for the storage pool.
      // You can use this flag only with Hyperdisk Balanced Storage Pools.
      long provisionedIops = 3000;
      // the throughput in MBps to provision for the storage pool.
      long provisionedThroughput = 140;
  
      createHyperdiskStoragePool(projectId, zone, storagePoolName, storagePoolType,
              capacityProvisioningType, provisionedCapacity, provisionedIops, provisionedThroughput);
    }
  
    // Creates a hyperdisk storagePool in a project
    public static StoragePool createHyperdiskStoragePool(String projectId, String zone,
                                                  String storagePoolName, String storagePoolType,
                                                  String capacityProvisioningType, long capacity,
                                                  long iops, long throughput)
            throws IOException, ExecutionException, InterruptedException, TimeoutException {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      try (StoragePoolsClient client = StoragePoolsClient.create()) {
        // Create a storagePool.
        StoragePool resource = StoragePool.newBuilder()
                .setZone(zone)
                .setName(storagePoolName)
                .setStoragePoolType(storagePoolType)
                .setCapacityProvisioningType(capacityProvisioningType)
                .setPoolProvisionedCapacityGb(capacity)
                .setPoolProvisionedIops(iops)
                .setPoolProvisionedThroughput(throughput)
                .build();
  
        InsertStoragePoolRequest request = InsertStoragePoolRequest.newBuilder()
                .setProject(projectId)
                .setZone(zone)
                .setStoragePoolResource(resource)
                .build();
  
        // Wait for the insert disk operation to complete.
        Operation operation = client.insertAsync(request).get(1, TimeUnit.MINUTES);
  
        if (operation.hasError()) {
          System.out.println("StoragePool creation failed!");
          throw new Error(operation.getError().toString());
        }
  
        // Wait for server update
        TimeUnit.SECONDS.sleep(10);
  
        StoragePool storagePool = client.get(projectId, zone, storagePoolName);
  
        System.out.printf("Storage pool '%s' has been created successfully", storagePool.getName());
  
        return storagePool;
      }
    }
  }

  Node.js

  // Import the Compute library
  const computeLib = require('@google-cloud/compute');
  const compute = computeLib.protos.google.cloud.compute.v1;
  
  // Instantiate a storagePoolClient
  const storagePoolClient = new computeLib.StoragePoolsClient();
  // Instantiate a zoneOperationsClient
  const zoneOperationsClient = new computeLib.ZoneOperationsClient();
  
  /**
   * TODO(developer): Update these variables before running the sample.
   */
  // Project ID or project number of the Google Cloud project you want to use.
  const projectId = await storagePoolClient.getProjectId();
  // Name of the zone in which you want to create the storagePool.
  const zone = 'us-central1-a';
  // Name of the storagePool you want to create.
  const storagePoolName = 'storage-pool-name';
  // The type of disk you want to create. This value uses the following format:
  // "projects/{projectId}/zones/{zone}/storagePoolTypes/(hyperdisk-throughput|hyperdisk-balanced)"
  const storagePoolType = `projects/${projectId}/zones/${zone}/storagePoolTypes/hyperdisk-balanced`;
  // Optional: The capacity provisioning type of the storage pool.
  // The allowed values are advanced and standard. If not specified, the value advanced is used.
  const capacityProvisioningType = 'advanced';
  // The total capacity to provision for the new storage pool, specified in GiB by default.
  const provisionedCapacity = 10240;
  // The IOPS to provision for the storage pool.
  // You can use this flag only with Hyperdisk Balanced Storage Pools.
  const provisionedIops = 10000;
  // The throughput in MBps to provision for the storage pool.
  const provisionedThroughput = 1024;
  
  async function callCreateComputeHyperdiskPool() {
    // Create a storagePool.
    const storagePool = new compute.StoragePool({
      name: storagePoolName,
      poolProvisionedCapacityGb: provisionedCapacity,
      poolProvisionedIops: provisionedIops,
      poolProvisionedThroughput: provisionedThroughput,
      storagePoolType,
      capacityProvisioningType,
      zone,
    });
  
    const [response] = await storagePoolClient.insert({
      project: projectId,
      storagePoolResource: storagePool,
      zone,
    });
  
    let operation = response.latestResponse;
  
    // Wait for the create storage pool operation to complete.
    while (operation.status !== 'DONE') {
      [operation] = await zoneOperationsClient.wait({
        operation: operation.name,
        project: projectId,
        zone: operation.zone.split('/').pop(),
      });
    }
  
    const createdStoragePool = (
      await storagePoolClient.get({
        project: projectId,
        zone,
        storagePool: storagePoolName,
      })
    )[0];
  
    console.log(JSON.stringify(createdStoragePool));
  }
  
  await callCreateComputeHyperdiskPool();

  다음 단계

  • Hyperdisk Storage Pool 관리 방법 알아보기