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 d'une taille supérieure à 160 Go, utilisez la AWS CLI, le kit SDK AWS 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 le contrôle de version, consultez Utiliser la console S3..

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

Chargement d'un objet en une seule opération à l'aide des kits SDK AWS, de l'API REST ou de la AWS CLI – Grâce à une seule opération PUT, vous pouvez charger un seul objet d'une taille maximale de 5 Go.
Chargement d'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.
Chargement d'un objet en plusieurs parties à l'aide des kits SDK AWS, de l'API REST ou de la AWS CLI – Grâce à l'API de chargement en plusieurs parties, vous pouvez charger un seul objet de grande taille, jusqu'à 5 To.

L'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 de plus amples informations, veuillez consulter Chargement et copie d'objets à l'aide d'un chargement partitionné.

Lors du chargement d'un objet, vous pouvez éventuellement demander à Amazon S3 de chiffrer l'objet avant de l'enregistrer sur disque, puis le déchiffrer lorsque vous le téléchargez. Pour de plus amples informations, veuillez consulter Protection des données à l'aide du chiffrement.

Cette procédure explique la façon de charger un des objets et des dossiers dans un compartiment 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, le Chiffrement ou les 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 la forme sample1.jpg et sample2.jpg.

Pour charger des dossiers et des fichiers dans un compartiment S3

Connectez-vous à la AWS Management Console et ouvrez la console Amazon S3 à l'adresse https://console.aws.amazon.com/s3/.
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 Add file (Ajouter un fichier) ou Add folder (Ajouter un dossier), puis choisissez les fichiers ou les dossiers à charger et Open (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 succès s'affiche sur la page Load: status (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 Storage class (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. Pour chiffrer les fichiers chargés à l'aide des clés gérées par Amazon S3, choisissez Amazon S3 key (SSE-S3) (Clé Amazon S3 (SSE-S3).
  
  Pour de plus amples informations, veuillez consulter Protection des données à l'aide du chiffrement côté serveur avec des clés de chiffrement gérées par Amazon S3 (SSE-S3).
3. Pour chiffrer les fichiers chargés avec AWS Key Management Service (AWS KMS), choisissez une AWS Key Management Serviceclé (SSE-KMS). Choisissez ensuite une option pour la AWS KMS clé.
  - Clé gérée par AWS — choisissez une clé gérée par AWS.
  - Choose from your KMS root keys (Choisissez parmi vos clés racine KMS) — sélectionnez une clé gérée par le client à partir d'une liste de clés KMS située dans la même région que votre compartiment.
    
    Pour en savoir plus sur la création de clés gérées par le client, consultez Création de clés dans le guide du développeur AWS Key Management Service. Pour en savoir plus sur la protection des données avec AWS KMS, consultez Protection des données grâce au chiffrement côté serveur avec AWS Key Management Service (SSE-KMS).
  - Entrez l'ARN de la clé racine KMS — spécifiez l'ARN de la clé AWS KMS pour une clé gérée par le client, puis saisissez l'Amazon Resource Name (ARN).
    
    Vous pouvez utiliser l'ARN de clé racine KMS pour permettre à un compte externe d'utiliser un objet protégé par une AWS KMS key. Pour ce faire, choisissez Enter KMS root key ARN (Entrer l'ARN de la clé primaire KMS), puis entrez l'Amazon Resource Name (ARN) du compte externe. Les administrateurs d'un compte externe qui disposent des autorisations d'utilisation sur un objet protégé par votre clé KMS peuvent ensuite restreindre l'accès en créant une politique IAM au niveau des ressources.
  Note
  Pour chiffrer des objets dans un compartiment, vous pouvez AWS KMS keys disponibles dans la même Région AWS que le compartiment.
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). Tapez un nom de balise dans le champ Key (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 un 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 le kit SDK AWS pour charger des objets dans Amazon S3. Le kit SDK fournit 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 quelques 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 required AWS SDK clients and commands for Node.js.
import { PutObjectCommand } from "@aws-sdk/client-s3";
import { s3Client } from "./libs/s3Client.js"; // Helper function that creates an Amazon S3 service client module.
import {path} from "path";
import {fs} from "fs";

const file = "OBJECT_PATH_AND_NAME"; // Path to and name of object. For example '../myFiles/index.js'.
const fileStream = fs.createReadStream(file);

// Set the parameters
export const uploadParams = {
  Bucket: "BUCKET_NAME",
  // Add the required 'Key' parameter using the 'path' module.
  Key: path.basename(file),
  // Add the required 'Body' parameter
  Body: fileStream,
};


// Upload file to specified bucket.
export const run = async () => {
  try {
    const data = await s3Client.send(new PutObjectCommand(uploadParams));
    console.log("Success", data);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();

PHP

Cette rubrique vous guide dans l'utilisation de classes provenant du kit AWS SDK for PHP pour charger un objet d'une taille maximale de 5 Go. Pour les fichiers plus volumineux, vous devez utiliser l'API de chargement partitionné. Pour de plus amples informations, veuillez consulter Chargement et copie d'objets à l'aide d'un chargement partitionné.

Cette rubrique part du principe que vous suivez déjà les instructions de la section 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\S3Client;
use Aws\S3\Exception\S3Exception;

$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

Le AWS SDK for Ruby - version 3 offre de deux façons de 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

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 seconde méthode d'AWS SDK for Ruby Version 3 pour charger un objet consiste à utiliser la méthode #put de Aws::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

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 de plus amples informations, veuillez consulter PUT Object.

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é