Esta página se ha traducido con Cloud Translation API.

Eliminar objetos

En esta página se explica cómo eliminar objetos de los segmentos de Cloud Storage.

Roles obligatorios

Para obtener los permisos que necesitas para eliminar objetos, pide a tu administrador que te conceda el rol de gestión de identidades y accesos Usuario de objetos de Storage (roles/storage.objectUser) para el segmento que contiene los objetos que quieres eliminar.

Si tienes previsto usar la consola de Google Cloud para completar las tareas de esta página, pide a tu administrador que te conceda el rol Administrador de Storage (roles/storage.admin) en lugar del rol Usuario de objetos de Storage (roles/storage.objectUser) o el rol básico Lector (roles/viewer), además del rol Usuario de objetos de Storage (roles/storage.objectUser).

Estos roles contienen los permisos necesarios para eliminar objetos. Para ver los permisos exactos que se necesitan, despliega la sección Permisos necesarios:

Permisos obligatorios

storage.objects.delete
storage.objects.list
- Este permiso solo es necesario cuando se usa la Google Cloud consola o cuando se usa la marca --recursive o comodines en la interfaz de línea de comandos de Google Cloud.
storage.buckets.list
- Este permiso solo es necesario cuando se usa la consola Google Cloud para seguir las instrucciones de esta página.

También puedes obtener estos permisos con otros roles predefinidos o roles personalizados.

Para obtener información sobre cómo conceder roles en los contenedores, consulta Usar IAM con contenedores.

Eliminar un objeto

Sigue estos pasos para eliminar objetos de uno de tus segmentos de Cloud Storage:

Consola

En la Google Cloud consola, ve a la página Segmentos de Cloud Storage.

Ir a Contenedores
En la lista de segmentos, haga clic en el nombre del segmento que contiene los objetos que quiere eliminar.

Se abrirá la página Detalles del segmento, con la pestaña Objetos seleccionada.
Desplázate hasta los objetos, que pueden estar en una carpeta.
Marca la casilla de cada objeto que quieras eliminar.

También puedes marcar la casilla de las carpetas para eliminar todos los objetos que contengan.
Haz clic en el botón Eliminar.
En el cuadro de diálogo que aparece, haz clic en Eliminar.

Si eliminas muchos objetos a la vez, puedes hacer un seguimiento del progreso de la eliminación haciendo clic en el icono Notificaciones de la consola Google Cloud . La consolaGoogle Cloud puede eliminar en bloque hasta varios millones de objetos y lo hace en segundo plano.

Para saber cómo obtener información detallada sobre los errores de las operaciones de Cloud Storage en la consola, consulta la sección Solución de problemas. Google Cloud

Línea de comandos

Usa el comando Google Cloud CLI gcloud storage rm:

gcloud storage rm gs://BUCKET_NAME/OBJECT_NAME

Donde:

BUCKET_NAME es el nombre del segmento que contiene el objeto que quieres eliminar. Por ejemplo, my-bucket.
OBJECT_NAME es el nombre del objeto que quieres eliminar. Por ejemplo, pets/dog.png.

Si la solicitud se realiza correctamente, la respuesta será similar a la del siguiente ejemplo:

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

Bibliotecas de cliente

C++

Para obtener más información, consulta la documentación de referencia de la API C++ de Cloud Storage.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación 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 obtener más información, consulta la documentación de referencia de la API C# de Cloud Storage.


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 obtener más información, consulta la documentación de referencia de la API Go de Cloud Storage.

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 obtener más información, consulta la documentación de referencia de la API Java de Cloud Storage.

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 obtener más información, consulta la documentación de referencia de la API Node.js de Cloud Storage.

/**
 * 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 obtener más información, consulta la documentación de referencia de la API PHP de Cloud Storage.

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 obtener más información, consulta la documentación de referencia de la API Python de Cloud Storage.

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 obtener más información, consulta la documentación de referencia de la API Ruby de Cloud Storage.

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

Tener instalada e inicializada la CLI de gcloud, que te permite generar un token de acceso para el encabezado Authorization.

Usa cURL para llamar a la API JSON con una solicitud DELETE:
```
curl -X DELETE \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/o/OBJECT_NAME"
```
Donde:
- BUCKET_NAME es el nombre del segmento que contiene el objeto que quieres eliminar. Por ejemplo, my-bucket.
- OBJECT_NAME es el nombre codificado en URL del objeto que quieres eliminar. Por ejemplo, pets/dog.png, codificado como URL pets%2Fdog.png.

API XML

Tener instalada e inicializada la CLI de gcloud, que te permite generar un token de acceso para el encabezado Authorization.

Usa cURL para llamar a la API XML con una solicitud DELETE Object:
```
curl -X DELETE \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage.googleapis.com/BUCKET_NAME/OBJECT_NAME"
```
Donde:
- BUCKET_NAME es el nombre del segmento que contiene el objeto que quieres eliminar. Por ejemplo, my-bucket.
- OBJECT_NAME es el nombre codificado en URL del objeto que quieres eliminar. Por ejemplo, pets/dog.png, codificado como URL pets%2Fdog.png.