Supprimer des objets

Sur cette page, vous allez découvrir comment supprimer des objets de vos buckets dans Cloud Storage.

Rôles requis

Pour obtenir les autorisations nécessaires pour supprimer des objets, demandez à votre administrateur de vous accorder le rôle IAM "Utilisateur d'objets Storage" (roles/storage.objectUser) sur le bucket contenant les objets que vous souhaitez supprimer.

Si vous prévoyez d'utiliser la console Google Cloud pour effectuer les tâches de cette page, demandez à votre administrateur de vous accorder le rôle d'administrateur de l'espace de stockage (roles/storage.admin) au lieu du rôle d'utilisateur d'objets Storage (roles/storage.objectUser), ou le rôle de base de lecteur (roles/viewer) en plus du rôle d'utilisateur d'objets Storage (roles/storage.objectUser).

Ces rôles contiennent les autorisations requises pour supprimer des objets. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

storage.objects.delete
storage.objects.list
- Cette autorisation n'est nécessaire que si vous utilisez la console Google Cloud , le flag --recursive ou des caractères génériques dans la Google Cloud CLI.
storage.buckets.list
- Cette autorisation n'est nécessaire que si vous utilisez la console Google Cloud pour exécuter les instructions de cette page.

Vous pouvez également obtenir ces autorisations avec d'autres rôles prédéfinis ou des rôles personnalisés.

Pour en savoir plus sur l'attribution de rôles sur des buckets, consultez Définir et gérer des stratégies IAM sur des buckets.

Supprimer un objet

Pour supprimer des objets de l'un de vos buckets Cloud Storage, procédez comme suit :

Console

Dans la console Google Cloud , accédez à la page Buckets de Cloud Storage.

Accéder à la page Buckets
Dans la liste des buckets, cliquez sur le nom du bucket qui contient les objets que vous souhaitez supprimer.

La page Informations sur le bucket s'ouvre avec l'onglet Objets sélectionné.
Accédez aux objets, qui peuvent se trouver dans un dossier.
Cochez la case correspondant à chaque objet que vous souhaitez supprimer.

Vous pouvez également cocher la case correspondant à un dossier pour supprimer tous les objets qu'il contient.
Cliquez sur le bouton Supprimer.
Dans la boîte de dialogue qui s'affiche, cliquez sur Supprimer.

Si vous supprimez plusieurs objets à la fois, vous pouvez suivre la progression de la suppression en cliquant sur l'icône Notifications de la console Google Cloud . La consoleGoogle Cloud peut supprimer plusieurs millions d'objets de manière groupée en arrière-plan.

Pour savoir comment obtenir des informations détaillées sur les erreurs liées à l'échec des opérations Cloud Storage dans la console Google Cloud , consultez Dépannage.

Ligne de commande

Exécutez la commande gcloud storage rm de la Google Cloud CLI :

gcloud storage rm gs://BUCKET_NAME/OBJECT_NAME

Où :

BUCKET_NAME correspond au nom du bucket contenant l'objet que vous souhaitez supprimer. Par exemple, my-bucket.
OBJECT_NAME correspond au nom de l'objet que vous souhaitez supprimer. Par exemple, pets/dog.png.

Si l'opération réussit, la réponse se présente comme suit :

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

Bibliothèques clientes

C++

Pour en savoir plus, consultez la documentation de référence de Cloud Storage en langage C++.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour les bibliothèques clientes.

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#

Pour en savoir plus, consultez la documentation de référence de Cloud Storage en langage C#.


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

Pour en savoir plus, consultez la documentation de référence de Cloud Storage en langage Go.

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

Pour en savoir plus, consultez la documentation de référence de Cloud Storage en langage Java.

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

Pour en savoir plus, consultez la documentation de référence de Cloud Storage en langage Node.js.

/**
 * 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

Pour en savoir plus, consultez la documentation de référence de Cloud Storage en langage PHP.

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

Pour en savoir plus, consultez la documentation de référence de Cloud Storage en langage Python.

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

Pour en savoir plus, consultez la documentation de référence de Cloud Storage en langage Ruby.

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

API REST

API JSON

Vous devez installer et initialiser la gcloud CLI afin de générer un jeton d'accès pour l'en-tête Authorization.

Utilisez cURL pour appeler l'API JSON avec une requête DELETE :
```
curl -X DELETE \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/o/OBJECT_NAME"
```
Où :
- BUCKET_NAME correspond au nom du bucket contenant l'objet que vous souhaitez supprimer. Par exemple, my-bucket.
- OBJECT_NAME correspond au nom de l'objet encodé au format d'URL que vous souhaitez supprimer. Par exemple, pets/dog.png, encodé au format d'URL : pets%2Fdog.png.

API XML

Vous devez installer et initialiser la gcloud CLI afin de générer un jeton d'accès pour l'en-tête Authorization.

Utilisez cURL pour appeler l'API XML avec une requête DELETE Object :
```
curl -X DELETE \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage.googleapis.com/BUCKET_NAME/OBJECT_NAME"
```
Où :
- BUCKET_NAME correspond au nom du bucket contenant l'objet que vous souhaitez supprimer. Par exemple, my-bucket.
- OBJECT_NAME correspond au nom de l'objet encodé au format d'URL que vous souhaitez supprimer. Par exemple, pets/dog.png, encodé au format d'URL : pets%2Fdog.png.