Génération d'une URL présignée pour charger un objet sur un compartiment S3 on Outposts

Pour accorder un accès limité dans le temps aux objets stockés localement dans un Outpost sans mettre à jour votre stratégie de compartiment, vous pouvez utiliser une URL présignée. Avec les URL présignées, vous pouvez, en tant que propriétaire du compartiment, partager des objets avec des personnes dans votre cloud privé virtuel (VPC) ou leur accorder la possibilité de télécharger ou de supprimer des objets.

Lorsque vous créez une URL présignée à l'aide de kits SDK AWS ou de AWS Command Line Interface (AWS CLI), vous associez l'URL à une action spécifique. Vous accordez également un accès limité dans le temps à l'URL présignée en choisissant un délai d'expiration personnalisé qui peut aller de 1 seconde à 7 jours. Lorsque vous partagez l'URL présignée, la personne dans le VPC peut effectuer l'action intégrée dans l'URL comme s'il s'agissait de l'utilisateur connecté d'origine. Lorsque l'URL atteint son délai d'expiration, elle expire et ne fonctionne plus.

Lorsque vous créez une URL présignée, vous devez fournir vos informations d'identification de sécurité, puis spécifier les éléments suivants :

• Un point d'accès pour Amazon Resource Name (ARN) du compartiment S3 on Outposts

• Une clé d'objet

• Une méthode HTTP (PUT pour le chargement d'objets)

• Une date et une heure d'expiration

Une URL présignée est uniquement valide pendant la durée spécifiée. Autrement dit, vous devez commencer l'action autorisée par l'URL avant la date et l'heure d'expiration. Vous pouvez utiliser une URL présignée plusieurs fois, jusqu'à la date et l'heure d'expiration. Si vous avez créé une URL présignée à l'aide d'un jeton temporaire, alors l'URL expire lorsque le jeton expire, même si vous avez créé l'URL avec une heure d'expiration postérieure.

Si l'action autorisée par l'URL présignée est composée de plusieurs étapes, comme un chargement partitionné, vous devez démarrer l'ensemble des étapes avant l'expiration. Si S3 on Outposts tente de démarrer une étape avec une URL expirée, vous recevrez une erreur.

Les utilisateurs du cloud privé virtuel (VPC) qui ont accès à l'URL présignée peuvent charger des objets. Par exemple, un utilisateur du VPC qui a accès à l'URL présignée peut charger un objet dans votre compartiment. Étant donné que les URL présignées accordent l'accès à votre compartiment S3 on Outposts à tout utilisateur possédant l'URL présignée, nous vous recommandons de protéger ces URL de manière appropriée. Pour plus d'informations sur la protection des URL présignées, veuillez consulter la section Limitation des capacités des URL présignées.

Toute personne qui possède des autorisations de sécurité valides peut créer une URL pré-signée. Cependant, l'URL présignée doit être créée par une personne disposant des autorisations nécessaires pour effectuer l'opération sur laquelle l'URL présignée est basée. Pour plus d'informations, consultez Utilisateurs habilités à créer une URL présignée.

Utiliser les kits SDK AWS pour générer une URL présignée pour une opération d'objet S3 on Outposts

Java

SDK pour Java 2.x

Cet exemple montre comment générer une URL présignée que vous pouvez utiliser pour charger un objet dans un compartiment S3 on Outposts pour une durée limitée. Pour plus d'informations, consultez Utilisation d'URL présignée pour S3 on Outposts.

    public static void signBucket(S3Presigner presigner, String outpostAccessPointArn, String keyName) {

        try {
            PutObjectRequest objectRequest = PutObjectRequest.builder()
                    .bucket(accessPointArn)
                    .key(keyName)
                    .contentType("text/plain")
                    .build();

            PutObjectPresignRequest presignRequest = PutObjectPresignRequest.builder()
                    .signatureDuration(Duration.ofMinutes(10))
                    .putObjectRequest(objectRequest)
                    .build();

            PresignedPutObjectRequest presignedRequest = presigner.presignPutObject(presignRequest);


            String myURL = presignedRequest.url().toString();
            System.out.println("Presigned URL to upload a file to: " +myURL);
            System.out.println("Which HTTP method must be used when uploading a file: " +
                    presignedRequest.httpRequest().method());

            // Upload content to the S3 on Outposts bucket by using this URL.
            URL url = presignedRequest.url();

            // Create the connection and use it to upload the new object by using the presigned URL.
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setDoOutput(true);
            connection.setRequestProperty("Content-Type","text/plain");
            connection.setRequestMethod("PUT");
            OutputStreamWriter out = new OutputStreamWriter(connection.getOutputStream());
            out.write("This text was uploaded as an object by using a presigned URL.");
            out.close();

            connection.getResponseCode();
            System.out.println("HTTP response code is " + connection.getResponseCode());

        } catch (S3Exception e) {
            e.getStackTrace();
        } catch (IOException e) {
            e.getStackTrace();
        }
    }

Python

SDK pour Python (Boto3)

Cet exemple montre comment générer une URL présignée qui peut exécuter une action S3 on Outposts pour une durée limitée. Pour plus d'informations, consultez Utilisation d'URL présignée pour S3 on Outposts. Pour effectuer une requête avec l'URL, utilisez le package Requests.

import argparse
import logging
import boto3
from botocore.exceptions import ClientError
import requests

logger = logging.getLogger(__name__)


def generate_presigned_url(s3_client, client_method, method_parameters, expires_in):
    """
    Generate a presigned S3 on Outposts URL that can be used to perform an action.

    :param s3_client: A Boto3 Amazon S3 client.
    :param client_method: The name of the client method that the URL performs.
    :param method_parameters: The parameters of the specified client method.
    :param expires_in: The number of seconds that the presigned URL is valid for.
    :return: The presigned URL.
    """
    try:
        url = s3_client.generate_presigned_url(
            ClientMethod=client_method,
            Params=method_parameters,
            ExpiresIn=expires_in
        )
        logger.info("Got presigned URL: %s", url)
    except ClientError:
        logger.exception(
            "Couldn't get a presigned URL for client method '%s'.", client_method)
        raise
    return url


def usage_demo():
    logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')

    print('-'*88)
    print("Welcome to the Amazon S3 on Outposts presigned URL demo.")
    print('-'*88)

    parser = argparse.ArgumentParser()
    parser.add_argument('accessPointArn', help="The name of the S3 on Outposts access point ARN.")
    parser.add_argument(
        'key', help="For a GET operation, the key of the object in S3 on Outposts. For a "
                    "PUT operation, the name of a file to upload.")
    parser.add_argument(
        'action', choices=('get', 'put'), help="The action to perform.")
    args = parser.parse_args()

    s3_client = boto3.client('s3')
    client_action = 'get_object' if args.action == 'get' else 'put_object'
    url = generate_presigned_url(
        s3_client, client_action, {'Bucket': args.accessPointArn, 'Key': args.key}, 1000)

    print("Using the Requests package to send a request to the URL.")
    response = None
    if args.action == 'get':
        response = requests.get(url)
    elif args.action == 'put':
        print("Putting data to the URL.")
        try:
            with open(args.key, 'r') as object_file:
                object_text = object_file.read()
            response = requests.put(url, data=object_text)
        except FileNotFoundError:
            print(f"Couldn't find {args.key}. For a PUT operation, the key must be the "
                  f"name of a file that exists on your computer.")

    if response is not None:
        print("Got response:")
        print(f"Status: {response.status_code}")
        print(response.text)

    print('-'*88)


if __name__ == '__main__':
    usage_demo()