Chargement d'objets - Amazon Simple Storage Service
Charger un objetUtilisation des écritures conditionnelles avec le téléchargement d'objets

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Chargement d'objets

Lorsque vous chargez un fichier dans Amazon S3, il est stocké en tant qu'objet S3. Les objets se composent des données du fichier et des métadonnées décrivant l'objet. Vous pouvez disposer d'un nombre illimité d'objets dans un compartiment. Avant de pouvoir charger des fichiers dans un compartiment Amazon S3, vous devez disposer d'autorisations en écriture pour le compartiment. Pour plus d'informations sur les autorisations d'accès, consultez Identity and Access Management pour Amazon S3.

Vous pouvez charger n'importe quel type de fichier (images, sauvegardes, données, films, etc.) dans un compartiment S3. La console Amazon S3 vous permet de charger des fichiers d'une taille maximale de 160 Go. Pour charger un fichier de plus de 160 Go, utilisez le AWS Command Line Interface (AWS CLI) ou Amazon S3 RESTAPI. AWS SDKs

Si vous chargez un objet avec un nom de clé qui existe déjà dans un compartiment pour lequel le contrôle de version est activé, Amazon S3 crée une autre version de l'objet au lieu de remplacer l'objet existant. Pour plus d'informations sur l'activation de la gestion des versions, consultezActivation de la gestion des versions sur les compartiments.

Selon la taille des données chargées, Amazon S3 propose les options suivantes :

  • Chargez un objet en une seule opération à l'aide de AWS SDKs RESTAPI, ou AWS CLI — En une seule PUT opération, vous pouvez télécharger un seul objet d'une taille maximale de 5 Go.

  • Charger un seul objet à l'aide de la console Amazon S3 : avec la console Amazon S3, vous pouvez charger un seul objet d'une taille maximale de 160 Go.

  • Chargez un objet en plusieurs parties à l'aide de la REST API commande AWS SDKs,, ou AWS CLI — À l'aide de l'APIopération de téléchargement partitionné, vous pouvez télécharger un seul objet volumineux, d'une taille maximale de 5 To.

    L'APIopération de téléchargement partitionné est conçue pour améliorer l'expérience de téléchargement pour les objets plus volumineux. Vous pouvez charger un objet en plusieurs parties. Ces parties d'objet peuvent être chargées indépendamment, dans n'importe quel ordre, et en parallèle. Vous pouvez utiliser un chargement partitionné pour les objets allant d'une taille maximale de 5 Mo à 5 To. Pour de plus amples informations, veuillez consulter Chargement et copie d'objets à l'aide d'un chargement partitionné.

Lorsque vous chargez un objet, celui-ci est automatiquement chiffré à l'aide du chiffrement côté serveur avec des clés gérées par Amazon S3 (SSE-S3) par défaut. Lorsque vous le téléchargez, l'objet est déchiffré. Pour plus d’informations, consultez Définition du comportement de chiffrement côté serveur par défaut pour les compartiments Amazon S3 et Protection des données à l'aide du chiffrement.

Lorsque vous chargez un objet, si vous souhaitez utiliser un autre type de chiffrement par défaut, vous pouvez également spécifier le chiffrement côté serveur avec des clés AWS Key Management Service (AWS KMS) (SSE-KMS) dans vos PUT requêtes S3 ou définir la configuration de chiffrement par défaut dans le compartiment de destination à utiliser SSE pour chiffrer vos données. KMS Pour plus d'informations sur SSE -KMS, consultezSpécification du chiffrement côté serveur avec AWS KMS (SSE-) KMS. Si vous souhaitez utiliser une KMS clé appartenant à un autre compte, vous devez être autorisé à l'utiliser. Pour plus d'informations sur les autorisations entre comptes pour les KMS clés, consultez la section Création de KMS clés utilisables par d'autres comptes dans le guide du AWS Key Management Service développeur.

Si vous rencontrez une erreur d'accès refusé (403 Interdit) dans Amazon S3, consultez Résoudre les erreurs d'accès refusé (403 Forbidden) dans Amazon S3 pour en savoir plus sur ses causes courantes.

Charger un objet

Cette procédure explique la façon de charger un des objets et des dossiers dans un compartiment Amazon S3 à l'aide de la console.

Lorsque vous chargez un objet, le nom de clé d'objet est le nom du fichier et les préfixes facultatifs. Dans la console Amazon S3, vous pouvez créer des dossiers pour organiser vos objets. Dans Amazon S3, les dossiers sont représentés sous la forme de préfixes qui apparaissent dans le nom de la clé d'objet. Si vous téléchargez un objet individuel dans un dossier de la console Amazon S3, le nom du dossier est inclus dans le nom de la clé de l'objet.

Par exemple, si vous chargez un objet nommé sample1.jpg dans un dossier nommé backup, le nom de la clé sera backup/sample1.jpg. Cependant, l'objet s'affiche dans la console en tant que sample1.jpg dans le dossier backup. Pour en savoir plus sur les noms de clé, consultez Utilisation des métadonnées d'objet.

Note

Si vous renommez un objet ou modifiez l'une de ses propriétés dans la console Amazon S3, par exemple Classe de stockage, Chiffrement ou Métadonnées, un nouvel objet est créé pour remplacer l'ancien. Si la gestion des versions S3 est activée, une nouvelle version de l'objet est créée et l'objet existant devient une version plus ancienne. Le rôle qui modifie la propriété devient également le propriétaire du nouvel objet ou (version de l'objet).

Lorsque vous chargez un dossier, Amazon S3 charge tous les fichiers et sous-dossiers du dossier spécifié dans le compartiment. Ensuite, il attribue un nom de clé d'objet qui combine le nom du fichier chargé et le nom du dossier. Par exemple, si vous chargez un dossier nommé /images qui contient deux fichiers, sample1.jpg et sample2.jpg, Amazon S3 charge les fichiers, puis attribue les noms de clé correspondants, images/sample1.jpg et images/sample2.jpg. Les noms de clé incluent le nom de dossier comme préfixe. La console Amazon S3 affiche uniquement la partie du nom de clé qui suit le dernier signe /. Par exemple, dans un dossier images, les objets images/sample1.jpg et images/sample2.jpg s'affichent sous les formes sample1.jpg et sample2.jpg.

Pour charger des dossiers et des fichiers dans un compartiment S3

  1. Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/s3/.

  2. Dans le panneau de navigation de gauche, choisissez Compartiments.

  3. Dans la liste Buckets (Compartiments), choisissez le nom du compartiment dans lequel vous souhaitez charger vos dossiers ou fichiers.

  4. Choisissez Upload.

  5. Dans la fenêtre Load (Charger), procédez de l'une des manières suivantes :

    • Faites glisser et déposez les fichiers et les dossiers dans la fenêtre Upload (Charge).

    • Choisissez Ajouter un fichier ou Ajouter un dossier, puis choisissez les fichiers ou les dossiers à charger et Ouvrir.

  6. Pour activer la gestion des versions, sous Destination, choisissez Enable Bucket Versioning (Activer la gestion des versions de compartiment).

  7. Pour charger les fichiers et les dossiers répertoriés sans configurer des options de chargement supplémentaires, choisissez Load (Charger).

    Amazon S3 charge les objets et les dossiers. Lorsque le chargement est terminé, un message de réussite s'affiche sur la page Charger : statut.

Pour configurer des propriétés d'objet supplémentaires

  1. Pour modifier les autorisations de la liste de contrôle d'accès, choisissez Permissions (Autorisations).

  2. Sous Liste de contrôle d'accès (ACL), modifiez les autorisations.

    Pour plus d'informations sur les autorisations d'accès aux objets, consultez Utilisation de la console S3 pour définir ACL des autorisations pour un objet. Vous pouvez octroyer l'accès en lecture à vos objets au public (tout le monde) pour tous les fichiers que vous chargez. Cependant, nous recommandons de ne pas modifier le paramètre par défaut de l'accès public en lecture. L'octroi de l'accès en lecture public est applicable à un petit sous-ensemble de cas d'utilisation, comme lorsque des compartiments sont utilisés pour des sites web. Vous pouvez toujours modifier les autorisations de l'objet après l'avoir chargé.

  3. Pour configurer d'autres propriétés supplémentaires, sélectionnez Properties (Propriétés).

  4. Dans Classe de stockage, choisissez la classe de stockage des fichiers à charger.

    Pour plus d'informations sur les classes de stockage, consultez Utilisation des classes de stockage Simple Storage Service (Amazon S3).

  5. Pour mettre à jour les paramètres de chiffrement de vos objets, sous Server-side encryption settings (Paramètres de chiffrement côté serveur), procédez comme suit.

    1. Choisissez Specify an encryption key (Spécifier une clé de chiffrement).

    2. Sous Paramètres de chiffrement, choisissez Utiliser les paramètres du compartiment pour le chiffrement par défaut ou Ignorer les paramètres du compartiment pour le chiffrement par défaut.

    3. Si vous avez choisi Ignorer les paramètres du compartiment pour le chiffrement par défaut, vous devez configurer les paramètres de chiffrement suivants.

      • Pour chiffrer les fichiers chargés à l'aide de clés gérées par Amazon S3, choisissez la clé gérée par Amazon S3 (SSE-S3).

        Pour de plus amples informations, veuillez consulter Utilisation du chiffrement côté serveur avec des clés gérées par Amazon S3 (SSE-S3).

      • Pour chiffrer les fichiers téléchargés à l'aide des clés stockées dans AWS Key Management Service (AWS KMS), choisissez AWS Key Management Service key (SSE-KMS). Choisissez ensuite l'une des options suivantes pour CléAWS KMS : 

        • Pour choisir parmi une liste de KMS clés disponibles, choisissez Choisir parmi votre AWS KMS keys, puis choisissez votre KMSclé dans la liste des clés disponibles.

          La clé Clé gérée par AWS (aws/s3) et la clé gérée par votre client apparaissent toutes deux dans cette liste. Pour plus d'informations sur les clés gérées par le client, consultez Clés de client et clés AWS dans le Guide du développeur AWS Key Management Service .

        • Pour saisir la KMS cléARN, choisissez Entrée AWS KMS key ARN, puis entrez votre KMS clé ARN dans le champ qui apparaît.

        • Pour créer une nouvelle clé gérée par le client dans la AWS KMS console, choisissez Create a KMS key.

          Pour plus d'informations sur la création d'un AWS KMS key, consultez la section Création de clés dans le Guide du AWS Key Management Service développeur.

        Important

        Vous ne pouvez utiliser que KMS les clés disponibles dans le même compartiment Région AWS que le bucket. La console Amazon S3 répertorie uniquement les 100 premières KMS clés de la même région que le compartiment. Pour utiliser une KMS clé qui n'est pas répertoriée, vous devez saisir votre KMS cléARN. Si vous souhaitez utiliser une KMS clé appartenant à un autre compte, vous devez d'abord être autorisé à utiliser la clé, puis vous devez la KMS saisirARN.

        Amazon S3 ne prend en charge que les KMS clés de chiffrement symétriques, et non les clés asymétriquesKMS. Pour plus d'informations, consultez la section Identification des KMS clés symétriques et asymétriques dans le manuel du AWS Key Management Service développeur.

  6. Pour utiliser des totaux de contrôle supplémentaires, sélectionnez On (Activé). Ensuite, pour le champ Checksum function (Fonction total de contrôle), sélectionnez la fonction que vous souhaitez utiliser. Amazon S3 calcule et stocke la valeur du total de contrôle après avoir reçu l'objet entier. Vous pouvez utiliser la case Precalculated value (Valeur précalculée) pour fournir une valeur précalculée. Si vous le faites, Amazon S3 compare la valeur que vous avez fournie à la valeur qu'il calcule. Si les deux valeurs ne correspondent pas, Amazon S3 génère une erreur.

    Les totaux de contrôle supplémentaires vous permettent de spécifier l'algorithme de total de contrôle que vous souhaitez utiliser pour vérifier vos données. Pour plus d'informations sur les totaux de contrôle supplémentaires, consultez Vérification de l'intégrité des objets.

  7. Pour ajouter des balises à tous les objets que vous chargez, choisissez Add tag (Ajouter une balise). Saisissez un nom de balise dans le champ Clé. Saisissez une valeur pour la balise.

    Le balisage des objets vous permet de classer le stockage par catégorie. Chaque balise est une paire clés-valeurs. Les valeurs de clés et de balises sont sensibles à la casse. Vous pouvez avoir jusqu'à 10 balises par objet. Une clé de balise peut comporter jusqu'à 128 caractères Unicode et les valeurs de balise peuvent comporter jusqu'à 255 caractères Unicode. Pour en savoir plus sur les balises d'objet, consultez Catégorisation de votre stockage à l'aide de balises.

  8. Pour ajouter des métadonnées, choisissez Add metadata (Ajouter des métadonnées).

    1. Sous Type, choisissez System defined (Défini par le système) ou User defined (Défini par l'utilisateur).

      Pour les métadonnées définies par le système, vous pouvez sélectionner des HTTP en-têtes courants, tels que Content-Type et Content-Disposition. Pour obtenir la liste des métadonnées définies par le système et savoir si vous pouvez ajouter la valeur, veuillez consulter Métadonnées d'objet définies par le système. Toute métadonnée commençant par le préfixe x-amz-meta- est traitée comme une métadonnée définie par l'utilisateur. Les métadonnées définies par l'utilisateur sont stockées avec l'objet et renvoyées une fois que vous avez téléchargé l'objet. Les clés et leurs valeurs doivent être conformes aux ASCII normes américaines. Les métadonnées définies par l'utilisateur peuvent atteindre 2 Ko. Pour plus d'informations sur les métadonnées définies par le système et par l'utilisateur, consultez Utilisation des métadonnées d'objet.

    2. Pour Key (Clé), choisissez une clé.

    3. Saisissez une valeur pour la clé.

  9. Pour charger vos objets, choisissez Load (Charger).

    Amazon S3 charge votre objet. Lorsque le chargement est terminé, un message de succès s'affiche sur la page Load: status (Charger : statut).

  10. Choisissez Exit (Quitter).

Vous pouvez envoyer une demande PUT pour télécharger un objet d'une taille maximale de 5 Go en une seule opération. Pour plus d'informations, veuillez consulter l'exemple PutObject dans la Référence de la commande AWS CLI .

Vous pouvez envoyer REST des demandes pour télécharger un objet. Vous pouvez envoyer une demande PUT pour charger des données en une seule opération. Pour plus d'informations, consultez la section PUTObjet.

Vous pouvez utiliser le AWS SDKs pour charger des objets dans Amazon S3. Ils SDKs fournissent des bibliothèques d'encapsulation pour vous permettre de télécharger facilement des données. Pour plus d'informations, consultez la liste des produits pris en charge SDKs.

Voici quelques exemples sélectionnés SDKs :

.NET

L'exemple de code C# crée deux objets avec deux demandes PutObjectRequest :

  • La première demande PutObjectRequestenregistre une chaîne de texte comme exemple de données d'objet. Elle spécifie aussi le nom du compartiment et celui de la clé d'objet.

  • La seconde demande PutObjectRequest charge un fichier en spécifiant son nom. La demande spécifie aussi l'en-tête ContentType et les métadonnées d'objet facultatives (un titre).

Pour plus d'informations sur la configuration et l'exécution des exemples de code, consultez Getting Started with the AWS SDK for. NETdans le AWS SDKfour. NETGuide du développeur. 

using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using System;
using System.Threading.Tasks;

namespace Amazon.DocSamples.S3
{
    class UploadObjectTest
    {
        private const string bucketName = "*** bucket name ***";
        // For simplicity the example creates two objects from the same file.
        // You specify key names for these objects.
        private const string keyName1 = "*** key name for first object created ***";
        private const string keyName2 = "*** key name for second object created ***";
        private const string filePath = @"*** file path ***";
        private static readonly RegionEndpoint bucketRegion = RegionEndpoint.EUWest1; 

        private static IAmazonS3 client;

        public static void Main()
        {
            client = new AmazonS3Client(bucketRegion);
            WritingAnObjectAsync().Wait();
        }

        static async Task WritingAnObjectAsync()
        {
            try
            {
                // 1. Put object-specify only key name for the new object.
                var putRequest1 = new PutObjectRequest
                {
                    BucketName = bucketName,
                    Key = keyName1,
                    ContentBody = "sample text"
                };

                PutObjectResponse response1 = await client.PutObjectAsync(putRequest1);

                // 2. Put the object-set ContentType and add metadata.
                var putRequest2 = new PutObjectRequest
                {
                    BucketName = bucketName,
                    Key = keyName2,
                    FilePath = filePath,
                    ContentType = "text/plain"
                };
                
                putRequest2.Metadata.Add("x-amz-meta-title", "someTitle");
                PutObjectResponse response2 = await client.PutObjectAsync(putRequest2);
            }
            catch (AmazonS3Exception e)
            {
                Console.WriteLine(
                        "Error encountered ***. Message:'{0}' when writing an object"
                        , e.Message);
            }
            catch (Exception e)
            {
                Console.WriteLine(
                    "Unknown encountered on server. Message:'{0}' when writing an object"
                    , e.Message);
            }
        }
    }
}
Java

L'exemple suivant crée deux objets. Le premier objet possède une chaîne de texte comme données et le second objet est un fichier. L'exemple crée le premier objet en spécifiant le nom du compartiment, la clé d'objet et les données de texte directement dans un appel de AmazonS3Client.putObject(). L'exemple crée le second objet en utilisant un objet PutObjectRequest qui spécifie le nom du compartiment, la clé d'objet et le chemin de fichier. L'objet PutObjectRequest spécifie aussi l'en-tête ContentType et les métadonnées de titre.

Pour obtenir des instructions sur la création et le test d'un échantillon fonctionnel, voir Getting Started dans le guide du AWS SDK for Java développeur.


import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.ObjectMetadata;
import com.amazonaws.services.s3.model.PutObjectRequest;

import java.io.File;
import java.io.IOException;

public class UploadObject {

    public static void main(String[] args) throws IOException {
        Regions clientRegion = Regions.DEFAULT_REGION;
        String bucketName = "*** Bucket name ***";
        String stringObjKeyName = "*** String object key name ***";
        String fileObjKeyName = "*** File object key name ***";
        String fileName = "*** Path to file to upload ***";

        try {
            // This code expects that you have AWS credentials set up per:
            // https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .withRegion(clientRegion)
                    .build();

            // Upload a text string as a new object.
            s3Client.putObject(bucketName, stringObjKeyName, "Uploaded String Object");

            // Upload a file as a new object with ContentType and title specified.
            PutObjectRequest request = new PutObjectRequest(bucketName, fileObjKeyName, new File(fileName));
            ObjectMetadata metadata = new ObjectMetadata();
            metadata.setContentType("plain/text");
            metadata.addUserMetadata("title", "someTitle");
            request.setMetadata(metadata);
            s3Client.putObject(request);
        } catch (AmazonServiceException e) {
            // The call was transmitted successfully, but Amazon S3 couldn't process
            // it, so it returned an error response.
            e.printStackTrace();
        } catch (SdkClientException e) {
            // Amazon S3 couldn't be contacted for a response, or the client
            // couldn't parse the response from Amazon S3.
            e.printStackTrace();
        }
    }
}
JavaScript

L'exemple suivant permet de charger un fichier existant dans un compartiment Amazon S3, dans une région spécifique.

import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";

const client = new S3Client({});

export const main = async () => {
  const command = new PutObjectCommand({
    Bucket: "test-bucket",
    Key: "hello-s3.txt",
    Body: "Hello S3!",
  });

  try {
    const response = await client.send(command);
    console.log(response);
  } catch (err) {
    console.error(err);
  }
};
PHP

Cet exemple vous explique comment utiliser les classes du AWS SDK for PHP pour télécharger un objet d'une taille maximale de 5 Go. Pour les fichiers plus volumineux, vous devez utiliser l'APIopération de téléchargement partitionné. Pour de plus amples informations, veuillez consulter Chargement et copie d'objets à l'aide d'un chargement partitionné.

Pour plus d'informations sur le AWS SDK for RubyAPI, rendez-vous sur AWS SDKfor Ruby - Version 2.

Exemple — Création d'un objet dans un compartiment Amazon S3 en chargeant des données

L'PHPexemple suivant crée un objet dans un compartiment spécifié en chargeant des données à l'aide de la putObject() méthode.

 require 'vendor/autoload.php';

use Aws\S3\Exception\S3Exception;
use Aws\S3\S3Client;

$bucket = '*** Your Bucket Name ***';
$keyname = '*** Your Object Key ***';

$s3 = new S3Client([
    'version' => 'latest',
    'region'  => 'us-east-1'
]);

try {
    // Upload data.
    $result = $s3->putObject([
        'Bucket' => $bucket,
        'Key'    => $keyname,
        'Body'   => 'Hello, world!',
        'ACL'    => 'public-read'
    ]);

    // Print the URL to the object.
    echo $result['ObjectURL'] . PHP_EOL;
} catch (S3Exception $e) {
    echo $e->getMessage() . PHP_EOL;
}
Ruby

La AWS SDK for Ruby version 3 propose deux méthodes pour télécharger un objet sur Amazon S3. La première utilise un chargeur de fichiers géré, qui simplifie le chargement de fichiers de toute taille à partir du disque. Pour utiliser la méthode de chargeur de fichier géré :

  1. Créez une instance de la classe Aws::S3::Resource.

  2. Référencez l'objet cible grâce au nom du compartiment et à la clé. Les objets résident dans un compartiment et disposent de clés uniques qui identifient chacun d'eux.

  3. Appelez#upload_file sur l'objet.

require "aws-sdk-s3"

# Wraps Amazon S3 object actions.
class ObjectUploadFileWrapper
  attr_reader :object

  # @param object [Aws::S3::Object] An existing Amazon S3 object.
  def initialize(object)
    @object = object
  end

  # Uploads a file to an Amazon S3 object by using a managed uploader.
  #
  # @param file_path [String] The path to the file to upload.
  # @return [Boolean] True when the file is uploaded; otherwise false.
  def upload_file(file_path)
    @object.upload_file(file_path)
    true
  rescue Aws::Errors::ServiceError => e
    puts "Couldn't upload file #{file_path} to #{@object.key}. Here's why: #{e.message}"
    false
  end
end

# Example usage:
def run_demo
  bucket_name = "doc-example-bucket"
  object_key = "my-uploaded-file"
  file_path = "object_upload_file.rb"

  wrapper = ObjectUploadFileWrapper.new(Aws::S3::Object.new(bucket_name, object_key))
  return unless wrapper.upload_file(file_path)

  puts "File #{file_path} successfully uploaded to #{bucket_name}:#{object_key}."
end

run_demo if $PROGRAM_NAME == __FILE__

La deuxième méthode utilisée par la AWS SDK for Ruby version 3 pour télécharger un objet utilise la #put méthode deAws::S3::Object. Cette méthode est utile si l'objet est une chaîne de caractères ou un objet I/O qui n'est pas un fichier sur disque. Pour utiliser la méthode :

  1. Créez une instance de la classe Aws::S3::Resource.

  2. Référencez l'objet cible grâce au nom du compartiment et à la clé.

  3. Appelez #put en passant la chaîne ou l'objet I/O.

require "aws-sdk-s3"

# Wraps Amazon S3 object actions.
class ObjectPutWrapper
  attr_reader :object

  # @param object [Aws::S3::Object] An existing Amazon S3 object.
  def initialize(object)
    @object = object
  end

  def put_object(source_file_path)
    File.open(source_file_path, "rb") do |file|
      @object.put(body: file)
    end
    true
  rescue Aws::Errors::ServiceError => e
    puts "Couldn't put #{source_file_path} to #{object.key}. Here's why: #{e.message}"
    false
  end
end

# Example usage:
def run_demo
  bucket_name = "doc-example-bucket"
  object_key = "my-object-key"
  file_path = "my-local-file.txt"

  wrapper = ObjectPutWrapper.new(Aws::S3::Object.new(bucket_name, object_key))
  success = wrapper.put_object(file_path)
  return unless success

  puts "Put file #{file_path} into #{object_key} in #{bucket_name}."
end

run_demo if $PROGRAM_NAME == __FILE__

Utilisation des écritures conditionnelles avec le téléchargement d'objets

Vous pouvez vérifier l'existence d'un objet dans votre compartiment avant de le créer à l'aide d'une écriture conditionnelle lors des opérations de téléchargement. Cela permet d'éviter le remplacement de données existantes. Les écritures conditionnelles valideront qu'aucun objet portant le même nom de clé ne se trouve déjà dans votre compartiment.

Vous pouvez effectuer une écriture conditionnelle en spécifiant l'en-tête If-None-Match conditionnel facultatif avec la valeur de * dans votre UploadObject API demande.

Pour plus d'informations sur les demandes conditionnelles, voir,Demandes conditionnelles.