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 dans 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), AWS les SDK ou l'API REST Amazon S3.

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 la gestion des versions, consultez Utilisation de la console S3.

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

Téléchargez un objet en une seule opération à l'aide AWS des SDK, de l'API REST 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.
Téléchargez un objet en plusieurs parties à l'aide AWS des SDK, de l'API REST ou AWS CLI — À l'aide de l'opération d'API de téléchargement en plusieurs parties, vous pouvez télécharger un seul objet volumineux d'une taille maximale de 5 To.

L'opération d'API de chargement partitionné est conçue pour améliorer l'expérience de 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 plus d’informations, consultez Chargement et copie d'objets à l'aide d'un chargement partitionné.

Lorsque vous chargez un objet, il 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 demandes PUT S3 ou définir la configuration de chiffrement par défaut dans le compartiment de destination afin d'utiliser SSE-KMS pour chiffrer vos données. Pour en savoir plus sur SSE-KMS, consultez Spécification du chiffrement côté serveur avec AWS KMS (SSE-KMS). Si vous souhaitez utiliser une clé KMS qui appartient à un autre compte, vous devez avoir l'autorisation d'utiliser la clé. Pour plus d'informations sur les autorisations intercomptes pour les clés KMS, consultez la section Creating KMS keys that other accounts can use (Création de clés KMS que d'autres comptes peuvent utiliser) dans le Guide du développeur AWS Key Management Service .

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

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

Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/s3/.
Dans le panneau de navigation de gauche, choisissez Compartiments.
Dans la liste Buckets (Compartiments), choisissez le nom du compartiment dans lequel vous souhaitez charger vos dossiers ou fichiers.
Choisissez Upload.
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.
Pour activer la gestion des versions, sous Destination, choisissez Enable Bucket Versioning (Activer la gestion des versions de compartiment).
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

Pour modifier les autorisations de la liste de contrôle d'accès, choisissez Permissions (Autorisations).
Sous Access control list (ACL) (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 des autorisations ACL 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é.
Pour configurer d'autres propriétés supplémentaires, sélectionnez Properties (Propriétés).
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).
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 des clés gérées par Amazon S3, choisissez 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 clés KMS disponibles, choisissez Choisir parmi vos AWS KMS keys, puis sélectionnez votre Clé KMS 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 l'ARN de la clé KMS, choisissez Enter AWS KMS key ARN, puis entrez l'ARN de votre clé KMS 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 les clés KMS disponibles dans le même compartiment Région AWS que le bucket. La console Amazon S3 répertorie uniquement les 100 premières clés KMS dans la même région que le compartiment. Pour utiliser une clé KMS qui n'est pas répertoriée, vous devez saisir l'ARN de votre clé KMS. Si vous souhaitez utiliser une clé KMS qui appartient à un autre compte, vous devez d'abord avoir l'autorisation d'utiliser cette clé KMS, puis saisir l'ARN de la clé KMS.
    Amazon S3 prend en charge seulement les clés KMS symétriques de chiffrement et ne prend pas en charge les clés KMS asymétriques. Pour plus d'informations, consultez la section Identifying symmetric and asymmetric KMS keys (Identification des clés KMS symétriques et asymétriques) dans le Guide du développeur AWS Key Management Service .
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.
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.
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 en-têtes HTTP 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 respecter les normes US-ASCII. 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é.
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).
Choisissez Exit (Quitter).

Vous pouvez utiliser les AWS kits SDK pour charger des objets dans Amazon S3. Les kits SDK fournissent des bibliothèques d'enveloppe pour simplifier le chargement des données. Pour plus d'informations, consultez la liste des kits SDK pris en charge.

Voici des exemples avec quelques kits SDK sélectionnés :

.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 obtenir des instructions sur la façon de créer et de tester un exemple pratique, consultez Exécution des exemples de code .NET Amazon S3.


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 les instructions sur la création et le test d'un exemple pratique, consultez Test des exemples de code Java Amazon S3.



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'opération d'API de chargement partitionné. Pour plus d’informations, consultez Chargement et copie d'objets à l'aide d'un chargement partitionné.

Cet exemple part du principe que vous suivez déjà les instructions pour Utilisation du kit AWS SDK for PHP et exécution d'exemples PHP et que le kit AWS SDK for PHP est correctement installé.

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

L'exemple de code PHP suivant crée un objet dans un compartiment spécifié en chargeant les données grâce à la méthode putObject(). Pour en savoir plus sur l'exécution des exemples PHP dans ce guide, consultez Exécution d'exemples PHP.


 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é :

Créez une instance de la classe Aws::S3::Resource.
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.
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 :

Créez une instance de la classe Aws::S3::Resource.
Référencez l'objet cible grâce au nom du compartiment et à la clé.
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__

Vous pouvez envoyer des demandes REST pour charger un objet. Vous pouvez envoyer une demande PUT pour charger des données en une seule opération. Pour plus d’informations, consultez Objet PUT.

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 .

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Modification des métadonnées d'un objet

Utilisation du chargement partitionné

Chargement d'objets

Note

Pour charger des dossiers et des fichiers dans un compartiment S3

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

Important

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