Excluir objetos

Nesta página, você aprenderá como excluir objetos em buckets do Cloud Storage.

Aviso: por padrão, o Cloud Storage retém os objetos excluídos de maneira reversível por sete dias. Se você excluir acidentalmente os objetos, poderá restaurar esses objetos excluídos de forma reversível durante esse período. No entanto, se você tiver desativado a exclusão reversível do bucket, não será possível recuperar os objetos excluídos. Para mais informações sobre como evitar a exclusão acidental de dados, consulte Opções para controlar ciclos de vida de dados.

Funções exigidas

Para receber as permissões necessárias para excluir objetos, peça ao administrador que conceda a você o papel do IAM de usuário de objetos do Storage (roles/storage.objectUser) para o bucket que contém os objetos que você quer excluir.

Se você planeja usar o console do Google Cloud para concluir as tarefas desta página, peça ao administrador que conceda a você o papel Administrador do Storage (roles/storage.admin) em vez do papel de usuário do objeto do Storage (roles/storage.objectUser) ou o papel básico de Leitor (roles/viewer), além do papel de Usuário do objeto do Storage (roles/storage.objectUser).

Esses papéis contêm as permissões necessárias para excluir objetos. Para conferir as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

• storage.objects.delete
• storage.objects.list
  • Essa permissão só é necessária ao usar o console do Google Cloud ou ao usar a sinalização --recursive ou caracteres curinga na CLI do Google Cloud.
• storage.buckets.list
  • Essa permissão só é necessária ao usar o console do Google Cloud para executar as instruções desta página.

Também é possível conseguir essas permissões com outros papéis predefinidos ou personalizados.

Para informações sobre como conceder papéis nos buckets, consulte Usar o IAM com buckets.

Excluir um objeto

Observação: a exclusão de dados poderá gerar cobranças de exclusão antecipada se os dados tiverem sido armazenados originalmente como Nearline Storage, Coldline Storage ou Archive Storage. Além disso, se você ativou o controle de versões de objeto no bucket, o objeto original permanecerá no bucket até ser excluído explicitamente usando o respectivo número de geração.

Conclua as etapas a seguir para excluir objetos a partir de um dos buckets do Cloud Storage:

Console

1. No Console do Google Cloud, acesse a página Buckets do Cloud Storage.
   

   Acessar buckets

2. Na lista de buckets, clique no nome daquele que contém os objetos que você quer excluir.

   A página Detalhes do bucket é aberta, com a guia Objetos selecionada.

3. Navegue até o objeto, que pode estar localizado em uma pasta.

4. Clique na caixa de seleção de cada objeto que você quer excluir.

   Também é possível clicar na caixa de seleção das pastas, o que excluirá todos os objetos contidos nessa pasta.

5. Clique no botão Excluir.

6. Clique em Excluir na caixa de diálogo exibida.

Se você excluir muitos objetos de uma vez, acompanhe o progresso da exclusão clicando no ícone Notificações no console do Google Cloud. O console do Google Cloud pode excluir em massa até vários milhões de objetos e faz isso em segundo plano.

Para saber como acessar informações detalhadas de erro sobre operações do Cloud Storage com falha no console do Google Cloud, consulte Solução de problemas.

Linha de comando

Use o comando gcloud storage rm da Google Cloud CLI:

gcloud storage rm gs://BUCKET_NAME/OBJECT_NAME

Em que:

• BUCKET_NAME é o nome do bucket que contém o objeto que você quer excluir. Por exemplo, my-bucket.
• OBJECT_NAME é o nome do objeto que você quer excluir. Por exemplo, pets/dog.png.

Se a operação for bem-sucedida, a resposta será semelhante a esta:

Removing objects:
Removing gs://example-bucket/file.txt...
  Completed 1/1

Observação: é possível excluir grupos de objetos com o mesmo prefixo, como objetos com nomes que imitem uma estrutura de pastas, usando a flag --recursive. Por exemplo: gcloud storage rm --recursive gs://my-bucket/dir/

Bibliotecas de cliente

C++

Para mais informações, consulte a documentação de referência da API Cloud Storage C++.

Para autenticar no Cloud Storage, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

namespace gcs = ::google::cloud::storage;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& object_name) {
  google::cloud::Status status =
      client.DeleteObject(bucket_name, object_name);

  if (!status.ok()) throw std::runtime_error(status.message());
  std::cout << "Deleted " << object_name << " in bucket " << bucket_name
            << "\n";
}

C#

Para mais informações, consulte a documentação de referência da API Cloud Storage C#.

Para autenticar no Cloud Storage, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

using Google.Cloud.Storage.V1;
using System;

public class DeleteFileSample
{
    public void DeleteFile(
        string bucketName = "your-unique-bucket-name",
        string objectName = "your-object-name")
    {
        var storage = StorageClient.Create();
        storage.DeleteObject(bucketName, objectName);
        Console.WriteLine($"Deleted {objectName}.");
    }
}

Go

Para mais informações, consulte a documentação de referência da API Cloud Storage Go.

Para autenticar no Cloud Storage, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// deleteFile removes specified object.
func deleteFile(w io.Writer, bucket, object string) error {
	// bucket := "bucket-name"
	// object := "object-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()

	o := client.Bucket(bucket).Object(object)

	// Optional: set a generation-match precondition to avoid potential race
	// conditions and data corruptions. The request to delete the file is aborted
	// if the object's generation number does not match your precondition.
	attrs, err := o.Attrs(ctx)
	if err != nil {
		return fmt.Errorf("object.Attrs: %w", err)
	}
	o = o.If(storage.Conditions{GenerationMatch: attrs.Generation})

	if err := o.Delete(ctx); err != nil {
		return fmt.Errorf("Object(%q).Delete: %w", object, err)
	}
	fmt.Fprintf(w, "Blob %v deleted.\n", object)
	return nil
}

Java

Para mais informações, consulte a documentação de referência da API Cloud Storage Java.

Para autenticar no Cloud Storage, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

import com.google.cloud.storage.Blob;
import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class DeleteObject {
  public static void deleteObject(String projectId, String bucketName, String objectName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // The ID of your GCS object
    // String objectName = "your-object-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    Blob blob = storage.get(bucketName, objectName);
    if (blob == null) {
      System.out.println("The object " + objectName + " wasn't found in " + bucketName);
      return;
    }
    BlobId idWithGeneration = blob.getBlobId();
    // Deletes the blob specified by its id. When the generation is present and non-null it will be
    // specified in the request.
    // If versioning is enabled on the bucket and the generation is present in the delete request,
    // only the version of the object with the matching generation will be deleted.
    // If instead you want to delete the current version, the generation should be dropped by
    // performing the following.
    // BlobId idWithoutGeneration =
    //    BlobId.of(idWithGeneration.getBucket(), idWithGeneration.getName());
    // storage.delete(idWithoutGeneration);
    storage.delete(idWithGeneration);

    System.out.println("Object " + objectName + " was permanently deleted from " + bucketName);
  }
}

Node.js

Para mais informações, consulte a documentação de referência da API Cloud Storage Node.js.

Para autenticar no Cloud Storage, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The ID of your GCS file
// const fileName = 'your-file-name';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

// Optional:
// Set a generation-match precondition to avoid potential race conditions
// and data corruptions. The request to delete is aborted if the object's
// generation number does not match your precondition. For a destination
// object that does not yet exist, set the ifGenerationMatch precondition to 0
// If the destination object already exists in your bucket, set instead a
// generation-match precondition using its generation number.
const deleteOptions = {
  ifGenerationMatch: generationMatchPrecondition,
};
async function deleteFile() {
  await storage.bucket(bucketName).file(fileName).delete(deleteOptions);

  console.log(`gs://${bucketName}/${fileName} deleted`);
}

deleteFile().catch(console.error);

PHP

Para mais informações, consulte a documentação de referência da API Cloud Storage PHP.

Para autenticar no Cloud Storage, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

use Google\Cloud\Storage\StorageClient;

/**
 * Delete an object.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $objectName The name of your Cloud Storage object.
 *        (e.g. 'my-object')
 */
function delete_object(string $bucketName, string $objectName): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $object->delete();
    printf('Deleted gs://%s/%s' . PHP_EOL, $bucketName, $objectName);
}

Python

Para mais informações, consulte a documentação de referência da API Cloud Storage Python.

Para autenticar no Cloud Storage, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

from google.cloud import storage


def delete_blob(bucket_name, blob_name):
    """Deletes a blob from the bucket."""
    # bucket_name = "your-bucket-name"
    # blob_name = "your-object-name"

    storage_client = storage.Client()

    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(blob_name)
    generation_match_precondition = None

    # Optional: set a generation-match precondition to avoid potential race conditions
    # and data corruptions. The request to delete is aborted if the object's
    # generation number does not match your precondition.
    blob.reload()  # Fetch blob metadata to use in generation_match_precondition.
    generation_match_precondition = blob.generation

    blob.delete(if_generation_match=generation_match_precondition)

    print(f"Blob {blob_name} deleted.")

Ruby

Para mais informações, consulte a documentação de referência da API Cloud Storage Ruby.

Para autenticar no Cloud Storage, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente.

def delete_file bucket_name:, file_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The ID of your GCS object
  # file_name = "your-file-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.bucket bucket_name, skip_lookup: true
  file    = bucket.file file_name

  file.delete

  puts "Deleted #{file.name}"
end

APIs REST

API JSON

Observação: cada solicitação de exclusão enviada à API JSON pode conter apenas um único objeto a ser excluído.

1. Ter a CLI gcloud instalada e inicializada, o que permite gerar um token de acesso para o cabeçalho Authorization.

2. Use cURL para chamar a API JSON com uma solicitação DELETE:

   curl -X DELETE \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/o/OBJECT_NAME"

   Em que:

   • BUCKET_NAME é o nome do bucket que contém o objeto que você quer excluir. Por exemplo, my-bucket.
   • OBJECT_NAME é o nome codificado por URL do objeto que você quer excluir. Por exemplo, pets/dog.png, codificado por URL como pets%2Fdog.png.

API XML

Observação: cada solicitação de exclusão enviada à API XML pode conter apenas um único objeto a ser excluído.

1. Ter a CLI gcloud instalada e inicializada, o que permite gerar um token de acesso para o cabeçalho Authorization.

2. Use cURL para chamar a API XML com uma solicitação DELETE Object:

   curl -X DELETE \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://storage.googleapis.com/BUCKET_NAME/OBJECT_NAME"

   Em que:

   • BUCKET_NAME é o nome do bucket que contém o objeto que você quer excluir. Por exemplo, my-bucket.
   • OBJECT_NAME é o nome codificado por URL do objeto que você quer excluir. Por exemplo, pets/dog.png, codificado por URL como pets%2Fdog.png.

Excluir objetos em massa

Para excluir cem mil ou mais objetos em massa, evite usar gcloud storage, já que o processo leva muito tempo para ser concluído. Em vez disso, considere uma das seguintes opções:

• O recurso Gerenciamento do ciclo de vida de objetos pode excluir qualquer quantidade de objetos. Para excluir objetos em massa no seu bucket usando esse recurso, defina uma regra de configuração de ciclo de vida no bucket em que a condição tenha Age definido como 0 dias e a ação esteja definida como delete. Depois de definir a regra, o Cloud Storage realiza a exclusão em massa de forma assíncrona.

• O console do Google Cloud também é uma opção recomendada ao excluir até um milhão de objetos. Depois de iniciar essa solicitação de exclusão, o processo ocorre em segundo plano. Para verificar o status da exclusão em massa, clique no botão Notificações () no cabeçalho do console do Google Cloud.

• Ao usar determinadas bibliotecas de cliente ou a API JSON diretamente, é possível agrupar em lote suas solicitações de exclusão para reduzir o número de conexões HTTP necessárias.

A seguir

• Saiba mais sobre o recurso de controle de versões de objetos.
• Conheça o recurso Gerenciamento do ciclo de vida de objetos.
• Veja como excluir um bucket.