VM 삭제

이 페이지에서는 인스턴스를 삭제하는 방법을 설명합니다. 인스턴스를 삭제하지 않고 일시적으로 중지하려면 인스턴스 중지 및 시작 또는 인스턴스 일시정지 및 재개를 참조하세요.

프로젝트에서 인스턴스와 연결된 리소스를 제거하려면 인스턴스를 삭제해야 합니다. 인스턴스가 인스턴스 그룹의 일부일 경우 특정 그룹 크기를 유지하기 위해 그룹에서 동일한 인스턴스를 다시 만들려고 할 수 있습니다. 인스턴스 그룹 크기를 조절하거나 자동 확장 처리를 다시 구성하세요.

시작하기 전에

아직 인증을 설정하지 않았다면 설정합니다. 인증은 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.

인스턴스 삭제

이 작업에 필요한 권한

이 태스크를 수행하려면 다음과 같은 권한이 있어야 합니다.

인스턴스에 대한 compute.instances.delete 권한

Google Cloud 콘솔, Google Cloud CLI 또는 API를 사용하여 인스턴스를 삭제합니다.

Console

Google Cloud Console의 VM 인스턴스 페이지로 이동합니다.
VM 인스턴스 페이지로 이동
삭제하려는 인스턴스를 선택합니다.
삭제 버튼을 클릭합니다.

gcloud

gcloud compute instances delete 명령어를 사용합니다. 이러한 방식으로 인스턴스를 삭제하면 인스턴스가 종료되고 인스턴스 목록에서 삭제됩니다. 인스턴스에 연결된 모든 리소스(예: 영구 디스크 및 고정 IP 주소)는 해제됩니다.

인스턴스를 삭제하려면 다음 명령어를 사용합니다.

gcloud compute instances delete example-instance [example-instance-2 example-instance-3..]

C#

compute/api/Compute.Samples/DeleteInstanceAsync.cs

GitHub에서 보기 의견 보내기


using Google.Cloud.Compute.V1;
using System.Threading.Tasks;

public class DeleteInstanceAsyncSample
{
    public async Task DeleteInstanceAsync(
        // TODO(developer): Set your own default values for these parameters or pass different values when calling this method.
        string projectId = "your-project-id",
        string zone = "us-central1-a",
        string machineName = "test-machine")
    {

        // Initialize client that will be used to send requests. This client only needs to be created
        // once, and can be reused for multiple requests.
        InstancesClient client = await InstancesClient.CreateAsync();

        // Make the request to delete a VM instance.
        var instanceDeletion = await client.DeleteAsync(projectId, zone, machineName);

        // Wait for the operation to complete using client-side polling.
        await instanceDeletion.PollUntilCompletedAsync();
    }
}

Go

compute/delete_instance.go

GitHub에서 보기 의견 보내기

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
)

// deleteInstance sends a delete request to the Compute Engine API and waits for it to complete.
func deleteInstance(w io.Writer, projectID, zone, instanceName string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	ctx := context.Background()
	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer instancesClient.Close()

	req := &computepb.DeleteInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	op, err := instancesClient.Delete(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to delete instance: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Instance deleted\n")

	return nil
}

자바

compute/cloud-client/src/main/java/compute/DeleteInstance.java

GitHub에서 보기 의견 보내기


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.DeleteInstanceRequest;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class DeleteInstance {

  public static void main(String[] args)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";
    deleteInstance(project, zone, instanceName);
  }

  // Delete the instance specified by `instanceName`
  // if it's present in the given project and zone.
  public static void deleteInstance(String project, String zone, String instanceName)
      throws IOException, InterruptedException, ExecutionException, 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. After completing all of your requests, call
    // the `instancesClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (InstancesClient instancesClient = InstancesClient.create()) {

      System.out.printf("Deleting instance: %s ", instanceName);

      // Describe which instance is to be deleted.
      DeleteInstanceRequest deleteInstanceRequest = DeleteInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstance(instanceName).build();

      OperationFuture<Operation, Operation> operation = instancesClient.deleteAsync(
          deleteInstanceRequest);
      // Wait for the operation to complete.
      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Instance deletion failed ! ! " + response);
        return;
      }
      System.out.println("Operation Status: " + response.getStatus());
    }
  }
}

Node.js

compute/deleteInstance.js

GitHub에서 보기 의견 보내기

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b'
// const instanceName = 'YOUR_INSTANCE_NAME';

const compute = require('@google-cloud/compute');

// Delete the instance specified by `instanceName` if it's present in the given project and zone.
async function deleteInstance() {
  const instancesClient = new compute.InstancesClient();

  console.log(`Deleting ${instanceName} from ${zone}...`);

  const [response] = await instancesClient.delete({
    project: projectId,
    zone,
    instance: instanceName,
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

  // Wait for the delete operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await operationsClient.wait({
      operation: operation.name,
      project: projectId,
      zone: operation.zone.split('/').pop(),
    });
  }

  console.log('Instance deleted.');
}

deleteInstance();

PHP

compute/instances/src/delete_instance.php

GitHub에서 보기 의견 보내기

use Google\Cloud\Compute\V1\Client\InstancesClient;
use Google\Cloud\Compute\V1\DeleteInstanceRequest;

/**
 * Delete an instance.
 *
 * @param string $projectId Your Google Cloud project ID.
 * @param string $zone Zone where the instance you want to delete is (like "us-central1-a").
 * @param string $instanceName Unique name for the Compute instance to delete.
 *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function delete_instance(
    string $projectId,
    string $zone,
    string $instanceName
) {
    // Delete the Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new DeleteInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->delete($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Deleted instance %s' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Failed to delete instance: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python

compute/client_library/snippets/instances/delete.py

GitHub에서 보기 의견 보내기

from __future__ import annotations

import sys
from typing import Any

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1

def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result

def delete_instance(project_id: str, zone: str, machine_name: str) -> None:
    """
    Send an instance deletion request to the Compute Engine API and wait for it to complete.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone you want to use. For example: “us-west3-b”
        machine_name: name of the machine you want to delete.
    """
    instance_client = compute_v1.InstancesClient()

    print(f"Deleting {machine_name} from {zone}...")
    operation = instance_client.delete(
        project=project_id, zone=zone, instance=machine_name
    )
    wait_for_extended_operation(operation, "instance deletion")
    print(f"Instance {machine_name} deleted.")

Ruby

google-cloud-compute-v1/samples/quickstart.rb

GitHub에서 보기 의견 보내기


require "google/cloud/compute/v1"

# Sends an instance deletion request to the Compute Engine API and waits for it to complete.
#
# @param [String] project project ID or project number of the Cloud project you want to use.
# @param [String] zone name of the zone you want to use. For example: "us-west3-b"
# @param [String] instance_name name of the instance you want to delete.
def delete_instance project:, zone:, instance_name:
  # Initialize client that will be used to send requests. This client only needs to be created
  # once, and can be reused for multiple requests.
  client = ::Google::Cloud::Compute::V1::Instances::Rest::Client.new

  puts "Deleting #{instance_name} from #{zone}..."
  begin
    # Make the request to delete a VM instance.
    operation = client.delete project: project, zone: zone, instance: instance_name
    # Wait for the delete operation to complete.
    operation = wait_until_done operation: operation

    if operation.error?
      warn "Error during deletion:", operation.error
    else
      compute_operation = operation.operation
      warn "Warning during creation:", compute_operation.warnings unless compute_operation.warnings.empty?
      puts "Instance #{instance_name} deleted."
    end
  rescue ::Google::Cloud::Error => e
    warn "Exception during deletion:", e
  end
end

REST

delete 메서드를 사용합니다.

DELETE https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-f/instances/example-instance

결제로 인한 영향

VM 인스턴스를 삭제한 후에는 다음 상황이 발생하지 않는 한 인스턴스 요금이 더 이상 청구되지 않습니다.

단독 테넌트 노드에서 호스팅되는 VM을 삭제하면 노드에서 호스팅되는 개별 VM 대신 단독 테넌트 노드 자체에 대한 요금이 계속 청구됩니다.
약정 사용 계약의 경우 리소스 사용 여부와 관계없이 약정한 리소스에 대한 요금이 계속 청구됩니다.
VM 인스턴스에 연결된 리소스를 보관할 경우 리소스를 삭제할 때까지 리소스에 대한 요금이 계속 청구됩니다. 예를 들어 VM 인스턴스를 삭제하고 영구 디스크를 유지하면 영구 디스크에 대한 요금이 계속 청구됩니다.

가격 정보에 대한 자세한 내용은 VM 인스턴스 가격 책정을 참조하세요.

종료 기간

인스턴스를 중지하거나 삭제하면 Compute Engine에서는 ACPI 종료 신호를 인스턴스에 보내고 인스턴스가 완전히 종료될 때까지 잠시 기다립니다. 이 유예 기간이 지난 후에도 인스턴스가 계속 실행 중이면 Compute Engine에서는 종료 스크립트가 계속 실행 중이더라도 인스턴스를 강제 종료합니다.

종료 기간의 길이는 인스턴스의 유형에 따라 다릅니다.

일반 인스턴스의 종료 기간은 보통 최소 90초 지속되지만 더 오래 지속될 수 있습니다.
선점형 인스턴스의 종료 기간은 30초 지속되며, 이는 선점형 프로세스 중에 발생하는 종료 기간과 동일합니다.

이 기간 동안 종료 스크립트를 실행하도록 선택한 경우 운영체제에서 종료를 완료하고 디스크에 버퍼를 플러시할 수 있도록 종료 스크립트에서 이 기간 내에 실행을 완료해야 합니다.

다음 단계

인스턴스 수명 주기 알아보기
영구 삭제하는 대신 인스턴스를 중지하기
영구 삭제하는 대신 인스턴스를 일시정지하기
VM을 수동으로 삭제하는 대신 VM이 자동으로 삭제되도록 예약하려면 VM의 런타임을 제한합니다.