Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Utilizzo di oggetti in un bucket di directory
Dopo aver creato un bucket di directory Amazon S3, puoi lavorare con gli oggetti utilizzando la console Amazon S3, AWS Command Line Interface ()AWS CLI e il. AWS SDKs
Per ulteriori informazioni sull'esecuzione di operazioni in blocco, sull'importazione, sul caricamento, sulla copia, sull'eliminazione e sul download di oggetti nei bucket della directory, consulta i seguenti argomenti.
**Topics**
+ [Importazione di oggetti in un bucket di directory](create-import-job.md)
+ [Operazioni con S3 Lifecycle per i bucket di directory](directory-buckets-objects-lifecycle.md)
+ [Utilizzo di Operazioni in batch con i bucket di directory](directory-buckets-objects-Batch-Ops.md)
+ [Aggiunta di dati agli oggetti nei bucket della directory](directory-buckets-objects-append.md)
+ [Ridenominazione degli oggetti nei bucket di directory](directory-buckets-objects-rename.md)
+ [Caricamento di oggetti in un bucket di directory](directory-buckets-objects-upload.md)
+ [Copia di oggetti da o verso un bucket di directory](directory-buckets-objects-copy.md)
+ [Eliminazione di oggetti da un bucket di directory](directory-bucket-delete-object.md)
+ [Download di un oggetto da un bucket di directory](directory-buckets-objects-GetExamples.md)
+ [Generazione di un bucket URLs di directory preimpostato per la condivisione di oggetti](directory-buckets-objects-generate-presigned-url-Examples.md)
+ [Recupero dei metadati degli oggetti dai bucket della directory](directory-buckets-objects-HeadObjectExamples.md)
+ [Elenco degli oggetti di un bucket di directory](directory-buckets-objects-listobjectsExamples.md)
# Importazione di oggetti in un bucket di directory
Dopo aver creato un bucket di directory in Amazon S3, puoi popolare il nuovo bucket con i dati utilizzando l'azione di importazione. L'importazione è un metodo ottimizzato di creazione di processi Operazioni in batch S3 per copiare oggetti da bucket per uso generico in bucket di directory.
**Nota**
Le seguenti limitazioni si applicano ai processi di importazione:
Il bucket di origine e il bucket di destinazione devono trovarsi nello stesso account. Regione AWS
Il bucket di origine non può essere un bucket di directory.
Gli oggetti di dimensioni superiori a 5 GB non sono supportati e verranno omessi dall'operazione di copia.
Gli oggetti nelle classi di archiviazione Glacier Flexible Retrieval, Glacier Deep Archive, livello di accesso archivio Intelligent-Tiering e livello Intelligent-Tiering Deep Archive devono essere ripristinati prima di poter essere importati.
Gli oggetti importati con algoritmi MD5 di checksum vengono convertiti per utilizzare i checksum. CRC32
Gli oggetti importati utilizzano la classe di storage Express One Zone, che ha una struttura di prezzi diversa dalle classi di storage utilizzate dai bucket per uso generico. Considera questa differenza di costo durante l'importazione di un gran numero di oggetti.
Durante la configurazione di un processo di importazione, specifica il bucket o il prefisso di origine da cui verranno copiati gli oggetti esistenti. Fornisci anche un ruolo AWS Identity and Access Management (IAM) che dispone delle autorizzazioni per accedere agli oggetti di origine. Amazon S3 avvia quindi un processo Operazioni in batch che copia gli oggetti e applica automaticamente le impostazioni della classe di archiviazione e del checksum appropriate.
Per configurare i processi di importazione, utilizza la console Amazon S3.
## Utilizzo della console Amazon S3
**Per importare oggetti in un bucket di directory**
1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Nel riquadro di navigazione a sinistra, scegli **Bucket**, quindi seleziona la scheda **Bucket di directory**. Seleziona il pulsante di opzione accanto al bucket di directory in cui desideri importare gli oggetti.
1. Scegli **Importa**.
1. Per **Origine**, inserisci il bucket per uso generico (o il percorso del bucket incluso il prefisso) contenente gli oggetti che desideri importare. Per scegliere un bucket per uso generico esistente da un elenco, scegli **S3 Browse**.
1. Per **Autorizzazione ad accedere e copiare gli oggetti di origine**, esegui una delle seguenti operazioni per specificare un ruolo IAM con le autorizzazioni necessarie per importare gli oggetti di origine:
+ Per consentire ad Amazon S3 di creare automaticamente un nuovo ruolo IAM, scegli **Crea un nuovo ruolo IAM**.
+ Per scegliere un ruolo IAM esistente da un elenco, seleziona **Scegli tra ruoli IAM esistenti**.
+ Per specificare un ruolo IAM esistente inserendo il relativo nome della risorsa Amazon (ARN), seleziona **Inserisci ARN ruolo IAM**, quindi inserisci l'ARN nel campo corrispondente.
1. Rivedi le informazioni visualizzate nelle sezioni **Destinazione** e **Impostazioni degli oggetti copiati**. Se le informazioni nella sezione **Destinazione** sono corrette, scegli **Importa** per avviare il processo di copia.
La console Amazon S3 visualizza lo stato del nuovo processo nella pagina **Operazioni in batch**. Per ulteriori informazioni sul processo, scegli il pulsante di opzione accanto al nome del processo, quindi nel menu **Azioni**, scegli **Visualizza dettagli**. Per aprire il bucket di directory in cui verranno importati gli oggetti, scegli **Visualizza la destinazione di importazione**.
# Operazioni con S3 Lifecycle per i bucket di directory
S3 Lifecycle aiuta a memorizzare gli oggetti in S3 Express One Zone nei bucket della directory in modo conveniente, eliminando gli oggetti scaduti per conto dell'utente. Per gestire il ciclo di vita degli oggetti, creare una configurazione S3 Lifecycle per il bucket della directory. Una configurazione del ciclo di vita di S3 è un insieme di regole che definisce le operazioni che Amazon S3 deve applicare a un gruppo di oggetti. Puoi impostare una configurazione del ciclo di vita di Amazon S3 su un bucket di directory utilizzando l'interfaccia a AWS riga di comando (AWS CLI), l'API REST di AWS SDKs Amazon S3 e. AWS CloudFormation
Nella configurazione del ciclo di vita, si utilizzano le regole per definire le azioni che Amazon S3 deve eseguire sugli oggetti. Per gli oggetti memorizzati nei bucket della directory, è possibile creare regole del ciclo di vita per far scadere gli oggetti man mano che diventano obsoleti. È inoltre possibile creare regole del ciclo di vita per eliminare i caricamenti multiparte incompleti nei bucket della directory con una frequenza giornaliera.
Quando si aggiunge una configurazione del ciclo di vita a un bucket, le regole di configurazione si applicano sia agli oggetti esistenti sia a quelli che vengono aggiunti in un secondo momento. Ad esempio, se oggi si aggiunge una regola di configurazione del ciclo di vita con un'azione di scadenza che fa scadere gli oggetti con un prefisso specifico 30 giorni dopo la creazione, S3 metterà in coda per la rimozione tutti gli oggetti esistenti che hanno più di 30 giorni e che hanno il prefisso specificato.
## Perché S3 Lifecycle è diverso per i bucket di directory
Per gli oggetti nei bucket della directory, è possibile creare regole del ciclo di vita per far scadere gli oggetti ed eliminare i caricamenti multiparte incompleti. Tuttavia, S3 Lifecycle per i bucket di directory non supporta le azioni di transizione tra le classi di storage.
**CreateSession**
Lifecycle utilizza le operazioni API pubbliche `DeleteObject` e `DeleteObjects` per far scadere gli oggetti nei bucket della directory. Per utilizzare queste operazioni API, S3 Lifecycle utilizzerà l'API `CreateSession` per stabilire credenziali di sicurezza temporanee per accedere agli oggetti nei bucket della directory. Per ulteriori informazioni, consulta [`CreateSession` nella *documentazione di riferimento delle API di Amazon S3*.](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateSession.html)
Se si ha una policy attiva che nega i permessi di eliminazione al principale del ciclo di vita, questa impedirà di consentire a S3 Lifecycle di eliminare gli oggetti per conto dell'utente.
### Utilizzo di una policy di bucket per concedere le autorizzazioni al principale del servizio S3 Lifecycle
La seguente policy sui bucket concede al servizio S3 Lifecycle l'autorizzazione principale a creare sessioni per eseguire operazioni come e. `DeleteObject` `DeleteObjects` Quando in una `CreateSession` richiesta non viene specificata alcuna modalità di sessione, la sessione viene creata con il privilegio massimo consentito dalle autorizzazioni in (prima il tentativo`ReadWrite`, poi se non è consentito). `ReadOnly` `ReadWrite` Tuttavia, `ReadOnly` le sessioni non sono sufficienti per le operazioni del ciclo di vita che modificano o eliminano oggetti. Pertanto, questo esempio richiede esplicitamente una modalità di `ReadWrite` sessione utilizzando la `s3express:SessionMode` chiave condition.
**Example — Policy Bucket per consentire `CreateSession` le chiamate con una modalità di `ReadWrite` sessione esplicita per le operazioni del ciclo di vita**
```
{
"Version":"2008-10-17",
"Statement":[
{
"Effect":"Allow",
"Principal": {
"Service":"lifecycle.s3.amazonaws.com"
},
"Action":"s3express:CreateSession",
"Condition": {
"StringEquals": {
"s3express:SessionMode": "ReadWrite"
}
},
"Resource":"arn:aws:s3express:us-east-2:412345678921:bucket/amzn-s3-demo-bucket--use2-az2--x-s3"
}
]
}
```
### Monitoraggio delle regole del ciclo di vita
Per gli oggetti archiviati nei bucket di directory, S3 Lifecycle genera registri degli eventi di gestione e dati. AWS CloudTrail Per ulteriori informazioni, consulta [esempi di file di CloudTrail registro per](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-log-files.html) S3 Express One Zone.
Per ulteriori informazioni sulla creazione di configurazioni del ciclo di vita e sulla risoluzione dei problemi relativi a S3 Lifecycle, consulta i seguenti argomenti:
**Topics**
# Creazione e gestione di una configurazione del ciclo di vita per il bucket della directory
È possibile creare una configurazione del ciclo di vita per i bucket di directory utilizzando AWS Command Line Interface (AWS CLI) e REST. AWS SDKs APIs
## Utilizzo della AWS CLI
È possibile utilizzare i seguenti AWS CLI comandi per gestire le configurazioni del ciclo di vita di S3:
+ `put-bucket-lifecycle-configuration`
+ `get-bucket-lifecycle-configuration`
+ `delete-bucket-lifecycle`
*Per istruzioni sulla configurazione AWS CLI, consulta [Developing with Amazon S3 using the AWS CLI nel Amazon S3 API](https://docs.aws.amazon.com/AmazonS3/latest/API/setup-aws-cli.html) Reference.*
La configurazione del ciclo di vita di Amazon S3 è un file XML. Tuttavia, quando utilizzi il AWS CLI, non puoi specificare il formato XML. È necessario invece specificare il formato JSON. Di seguito sono riportati esempi di configurazioni del ciclo di vita XML e le configurazioni JSON equivalenti che è possibile specificare in un comando. AWS CLI
Il seguente esempio di AWS CLI inserisce una politica di configurazione del ciclo di vita in un bucket di directory. Questa policy specifica che tutti gli oggetti che hanno il prefisso contrassegnato (myprefix) e la dimensione dell'oggetto definita scadono dopo 7 giorni. Per utilizzare questo comando, sostituisci *user input placeholder* con le tue informazioni.
Salva la policy di configurazione del ciclo di vita in un file JSON. In questo esempio, il file si chiama lifecycle1.json.
**Example**
```
{
"Rules": [
{
"Expiration": {
"Days": 7
},
"ID": "Lifecycle expiration rule",
"Filter": {
"And": {
"Prefix": "myprefix/",
"ObjectSizeGreaterThan": 500,
"ObjectSizeLessThan": 64000
}
},
"Status": "Enabled"
}
]
}
```
Inviare il file JSON come parte del comando CLI `put-bucket-lifecycle-configuration`. Per usare questo comando, sostituire *user input placeholder* con le proprie informazioni.
```
aws s3api put-bucket-lifecycle-configuration --region us-west-2 --profile default --bucket amzn-s3-demo-bucket--usw2-az1--x-s3 --lifecycle-configuration file://lc-policy.json --checksum-algorithm crc32c
```
**Example**
```
Lifecycle expiration rule
myprefix/
500
64000
Enabled
7
```
## Usando il AWS SDKs
------
#### [ SDK for Java ]
**Example**
```
import software.amazon.awssdk.services.s3.model.PutBucketLifecycleConfigurationRequest;
import software.amazon.awssdk.services.s3.model.PutBucketLifecycleConfigurationResponse;
import software.amazon.awssdk.services.s3.model.ChecksumAlgorithm;
import software.amazon.awssdk.services.s3.model.BucketLifecycleConfiguration;
import software.amazon.awssdk.services.s3.model.LifecycleRule;
import software.amazon.awssdk.services.s3.model.LifecycleRuleFilter;
import software.amazon.awssdk.services.s3.model.LifecycleExpiration;
import software.amazon.awssdk.services.s3.model.LifecycleRuleAndOperator;
import software.amazon.awssdk.services.s3.model.GetBucketLifecycleConfigurationResponse;
import software.amazon.awssdk.services.s3.model.GetBucketLifecycleConfigurationRequest;
import software.amazon.awssdk.services.s3.model.DeleteBucketLifecycleRequest;
import software.amazon.awssdk.services.s3.model.DeleteBucketLifecycleResponse;
import software.amazon.awssdk.services.s3.model.AbortIncompleteMultipartUpload;
// PUT a Lifecycle policy
LifecycleRuleFilter objectExpirationFilter = LifecycleRuleFilter.builder().and(LifecycleRuleAndOperator.builder().prefix("dir1/").objectSizeGreaterThan(3L).objectSizeLessThan(20L).build()).build();
LifecycleRuleFilter mpuExpirationFilter = LifecycleRuleFilter.builder().prefix("dir2/").build();
LifecycleRule objectExpirationRule = LifecycleRule.builder().id("lc").filter(objectExpirationFilter).status("Enabled").expiration(LifecycleExpiration.builder()
.days(10)
.build())
.build();
LifecycleRule mpuExpirationRule = LifecycleRule.builder().id("lc-mpu").filter(mpuExpirationFilter).status("Enabled").abortIncompleteMultipartUpload(AbortIncompleteMultipartUpload.builder()
.daysAfterInitiation(10)
.build())
.build();
PutBucketLifecycleConfigurationRequest putLifecycleRequest = PutBucketLifecycleConfigurationRequest.builder()
.bucket("amzn-s3-demo-bucket--usw2-az1--x-s3")
.checksumAlgorithm(ChecksumAlgorithm.CRC32)
.lifecycleConfiguration(
BucketLifecycleConfiguration.builder()
.rules(objectExpirationRule, mpuExpirationRule)
.build()
).build();
PutBucketLifecycleConfigurationResponse resp = client.putBucketLifecycleConfiguration(putLifecycleRequest);
// GET the Lifecycle policy
GetBucketLifecycleConfigurationResponse getResp = client.getBucketLifecycleConfiguration(GetBucketLifecycleConfigurationRequest.builder().bucket("amzn-s3-demo-bucket--usw2-az1--x-s3").build());
// DELETE the Lifecycle policy
DeleteBucketLifecycleResponse delResp = client.deleteBucketLifecycle(DeleteBucketLifecycleRequest.builder().bucket("amzn-s3-demo-bucket--usw2-az1--x-s3").build());
```
------
#### [ SDK for Go ]
**Example**
```
package main
import (
"context"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/aws/aws-sdk-go-v2/service/s3/types"
)
// PUT a Lifecycle policy
func putBucketLifecycleConfiguration(client *s3.Client, bucketName string ) error {
lifecycleConfig := &s3.PutBucketLifecycleConfigurationInput{
Bucket: aws.String(bucketName),
LifecycleConfiguration: &types.BucketLifecycleConfiguration{
Rules: []types.LifecycleRule{
{
ID: aws.String("lc"),
Filter: &types.LifecycleRuleFilter{
And: &types.LifecycleRuleAndOperator{
Prefix: aws.String("foo/"),
ObjectSizeGreaterThan: aws.Int64(1000000),
ObjectSizeLessThan: aws.Int64(100000000),
},
},
Status: types.ExpirationStatusEnabled,
Expiration: &types.LifecycleExpiration{
Days: aws.Int32(int32(1)),
},
},
{
ID: aws.String("abortmpu"),
Filter: &types.LifecycleRuleFilter{
Prefix: aws.String("bar/"),
},
Status: types.ExpirationStatusEnabled,
AbortIncompleteMultipartUpload: &types.AbortIncompleteMultipartUpload{
DaysAfterInitiation: aws.Int32(int32(5)),
},
},
},
},
}
_, err := client.PutBucketLifecycleConfiguration(context.Background(), lifecycleConfig)
return err
}
// Get the Lifecycle policy
func getBucketLifecycleConfiguration(client *s3.Client, bucketName string) error {
getLifecycleConfig := &s3.GetBucketLifecycleConfigurationInput{
Bucket: aws.String(bucketName),
}
resp, err := client.GetBucketLifecycleConfiguration(context.Background(), getLifecycleConfig)
if err != nil {
return err
}
return nil
}
// Delete the Lifecycle policy
func deleteBucketLifecycleConfiguration(client *s3.Client, bucketName string) error {
deleteLifecycleConfig := &s3.DeleteBucketLifecycleInput{
Bucket: aws.String(bucketName),
}
_, err := client.DeleteBucketLifecycle(context.Background(), deleteLifecycleConfig)
return err
}
func main() {
cfg, err := config.LoadDefaultConfig(context.Background(), config.WithRegion("us-west-2")) // Specify your region here
if err != nil {
log.Fatalf("unable to load SDK config, %v", err)
}
s3Client := s3.NewFromConfig(cfg)
bucketName := "amzn-s3-demo-bucket--usw2-az1--x-s3"
putBucketLifecycleConfiguration(s3Client, bucketName)
getBucketLifecycleConfiguration(s3Client, bucketName)
deleteBucketLifecycleConfiguration(s3Client, bucketName)
getBucketLifecycleConfiguration(s3Client, bucketName)
}
```
------
#### [ SDK for .NET ]
**Example**
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class LifecycleTest
{
private const string bucketName = "amzn-s3-demo-bucket--usw2-az1--x-s3";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 client;
public static void Main()
{
client = new AmazonS3Client(bucketRegion);
AddUpdateDeleteLifecycleConfigAsync().Wait();
}
private static async Task AddUpdateDeleteLifecycleConfigAsync()
{
try
{
var lifeCycleConfiguration = new LifecycleConfiguration()
{
Rules = new List
{
new LifecycleRule
{
Id = "delete rule",
Filter = new LifecycleFilter()
{
LifecycleFilterPredicate = new LifecyclePrefixPredicate()
{
Prefix = "projectdocs/"
}
},
Status = LifecycleRuleStatus.Enabled,
Expiration = new LifecycleRuleExpiration()
{
Days = 10
}
}
}
};
// Add the configuration to the bucket.
await AddExampleLifecycleConfigAsync(client, lifeCycleConfiguration);
// Retrieve an existing configuration.
lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client);
// Add a new rule.
lifeCycleConfiguration.Rules.Add(new LifecycleRule
{
Id = "mpu abort rule",
Filter = new LifecycleFilter()
{
LifecycleFilterPredicate = new LifecyclePrefixPredicate()
{
Prefix = "YearlyDocuments/"
}
},
Expiration = new LifecycleRuleExpiration()
{
Days = 10
},
AbortIncompleteMultipartUpload = new LifecycleRuleAbortIncompleteMultipartUpload()
{
DaysAfterInitiation = 10
}
});
// Add the configuration to the bucket.
await AddExampleLifecycleConfigAsync(client, lifeCycleConfiguration);
// Verify that there are now two rules.
lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client);
Console.WriteLine("Expected # of rulest=2; found:{0}", lifeCycleConfiguration.Rules.Count);
// Delete the configuration.
await RemoveLifecycleConfigAsync(client);
// Retrieve a nonexistent configuration.
lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client);
}
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);
}
}
static async Task AddExampleLifecycleConfigAsync(IAmazonS3 client, LifecycleConfiguration configuration)
{
PutLifecycleConfigurationRequest request = new PutLifecycleConfigurationRequest
{
BucketName = bucketName,
Configuration = configuration
};
var response = await client.PutLifecycleConfigurationAsync(request);
}
static async Task RetrieveLifecycleConfigAsync(IAmazonS3 client)
{
GetLifecycleConfigurationRequest request = new GetLifecycleConfigurationRequest
{
BucketName = bucketName
};
var response = await client.GetLifecycleConfigurationAsync(request);
var configuration = response.Configuration;
return configuration;
}
static async Task RemoveLifecycleConfigAsync(IAmazonS3 client)
{
DeleteLifecycleConfigurationRequest request = new DeleteLifecycleConfigurationRequest
{
BucketName = bucketName
};
await client.DeleteLifecycleConfigurationAsync(request);
}
}
}
```
------
#### [ SDK for Python ]
**Example**
```
import boto3
client = boto3.client("s3", region_name="us-west-2")
bucket_name = 'amzn-s3-demo-bucket--usw2-az1--x-s3'
client.put_bucket_lifecycle_configuration(
Bucket=bucket_name,
ChecksumAlgorithm='CRC32',
LifecycleConfiguration={
'Rules': [
{
'ID': 'lc',
'Filter': {
'And': {
'Prefix': 'foo/',
'ObjectSizeGreaterThan': 1000000,
'ObjectSizeLessThan': 100000000,
}
},
'Status': 'Enabled',
'Expiration': {
'Days': 1
}
},
{
'ID': 'abortmpu',
'Filter': {
'Prefix': 'bar/'
},
'Status': 'Enabled',
'AbortIncompleteMultipartUpload': {
'DaysAfterInitiation': 5
}
}
]
}
)
result = client.get_bucket_lifecycle_configuration(
Bucket=bucket_name
)
client.delete_bucket_lifecycle(
Bucket=bucket_name
)
```
------
# Risoluzione dei problemi di S3 Lifecycle per i bucket di directory
**Topics**
+ [La configurazione del ciclo di vita è impostata ma gli oggetti nel bucket della directory non scadono](#troubleshoot-directory-bucket-lifecycle-1)
+ [Come posso monitorare le azioni intraprese dalle mie regole del ciclo di vita?](#troubleshoot-directory-bucket-lifecycle-2)
## La configurazione del ciclo di vita è impostata ma gli oggetti nel bucket della directory non scadono
S3 Lifecycle for directory buckets utilizza public per eliminare oggetti in S3 APIs Express One Zone. Per utilizzare Object Level Public APIs, devi concedere l'autorizzazione `CreateSession` e consentire a S3 Lifecycle di eliminare i tuoi oggetti. Se si dispone di una policy attiva che nega le eliminazioni, questa impedirà di consentire a S3 Lifecycle di eliminare gli oggetti per conto dell'utente.
È importante configurare correttamente le policy di bucket per assicurarsi che gli oggetti da eliminare siano idonei alla scadenza. Puoi controllare AWS CloudTrail i log di `AccessDenied` Trails for `CreateSession` API invocations per verificare se l'accesso è stato CloudTrail negato. Il controllo dei CloudTrail log può aiutarti a risolvere i problemi di accesso e a identificare la causa principale degli errori di accesso negato. È quindi possibile correggere i controlli di accesso errati aggiornando le policy pertinenti.
Se si conferma che le policy di bucket sono impostate correttamente e si riscontrano ancora problemi, si consiglia di rivedere le regole del ciclo di vita per assicurarsi che siano applicate al giusto sottoinsieme di oggetti.
## Come posso monitorare le azioni intraprese dalle mie regole del ciclo di vita?
Puoi utilizzare AWS CloudTrail i registri degli eventi dei dati per monitorare le azioni intraprese da S3 Lifecycle nei bucket di directory. [Per ulteriori informazioni, consulta esempi di file di registro. CloudTrail ](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-log-files.html)
# Utilizzo di Operazioni in batch con i bucket di directory
Puoi utilizzare Operazioni in batch Amazon S3 per eseguire operazioni su oggetti archiviati in bucket S3. Per ulteriori informazioni su Operazioni in batch S3, consulta [Esecuzione di operazioni in batch su larga scala su oggetti Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops.html).
I seguenti argomenti trattano l'esecuzione di operazioni in batch su oggetti memorizzati nella classe di storage S3 Express One Zone in bucket di directory.
**Topics**
+ [Utilizzo di Operazioni in batch con i bucket di directory](#UsingBOPsDirectoryBuckets)
+ [Differenze principali](#UsingBOPsDirectoryBucketsKeyDiffs)
## Utilizzo di Operazioni in batch con i bucket di directory
È possibile eseguire l'operazione di **copia** e le operazioni di **invocazione della funzione AWS Lambda ** sugli oggetti memorizzati nei bucket della directory. Con **Copia**, è possibile copiare oggetti tra bucket dello stesso tipo (ad esempio, da un bucket directory a un bucket directory). Inoltre, puoi copiare oggetti tra bucket per uso generico e bucket di directory. Con ** AWS Lambda la funzione Invoke**, puoi usare una funzione Lambda per eseguire azioni sugli oggetti nel tuo bucket di directory con il codice che definisci.
**Copia di oggetti**
Puoi copiare tra lo stesso tipo di bucket o tra bucket di directory e bucket per uso generico. Quando si copia in un bucket di directory, è necessario utilizzare il formato di nome della risorsa Amazon (ARN) corretto per questo tipo di bucket. Il formato ARN per un bucket di directory è `arn:aws:s3express:region:account-id:bucket/bucket-base-name--x-s3`.
**Nota**
La copia di oggetti tra diversi Regioni AWS non è supportata quando il bucket di origine o di destinazione si trova in una zona locale. AWS I bucket di origine e di destinazione devono avere lo stesso Regione AWS padre. I bucket di origine e di destinazione possono essere di tipo diverso (zona di disponibilità o zona locale).
Puoi anche popolare il bucket di directory con dati utilizzando l'azione **Importa** nella console S3. L'azione **Importa** è un metodo ottimizzato di creazione di processi Operazioni in batch S3 per copiare oggetti da bucket per uso generico in bucket di directory. Per i processi di copia **Importa** da bucket per uso generico a bucket di directory, S3 genera automaticamente un manifesto. Per ulteriori informazioni, consulta [Importazione di oggetti in un bucket della directory](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-import-job.html) e [Specifica di un manifesto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/specify-batchjob-manifest.html).
**Invocazione di funzioni Lambda (`LambdaInvoke`)**
Esistono requisiti speciali per l'uso di Operazioni in batch per invocare funzioni Lambda che agiscono sui bucket della directory. Ad esempio, è necessario strutturare la richiesta Lambda utilizzando uno schema di invocazione JSON v2 e specificare InvocationSchemaVersion 2.0 quando si crea il processo. Per ulteriori informazioni, consulta [Invoca funzione AWS Lambda](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-invoke-lambda.html).
## Differenze principali
Di seguito sono elencate le differenze principali quando si utilizza Operazioni in batch per eseguire operazioni in blocco su oggetti archiviati in bucket di directory con la classe di storage S3 Express One Zone:
+ Per i bucket di directory, sono supportati SSE-S3 e la crittografia lato server con chiavi AWS Key Management Service () (AWS KMS SSE-KMS). Se si effettua una richiesta `CopyObject` che specifica di utilizzare la crittografia lato server con chiavi fornite dal cliente (SSE-C) su un bucket di directory (di origine o destinazione), la risposta restituisce un errore HTTP `400 (Bad Request)`.
Si consiglia di utilizzare la configurazione di crittografia predefinita del bucket e di non sovrascrivere la crittografia predefinita del bucket nelle richieste `CreateSession` o nelle richieste di oggetti `PUT`. I nuovi oggetti vengono quindi crittografati automaticamente con le impostazioni di crittografia desiderate. [Per ulteriori informazioni sui comportamenti di sovrascrittura della crittografia nei bucket di directory e su come crittografare nuove copie di oggetti in un bucket di directory con SSE-KMS, vedere Specificazione della crittografia lato server con per il caricamento di nuovi oggetti. AWS KMS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-specifying-kms-encryption.html)
Le chiavi dei bucket S3 non sono supportate quando si copiano oggetti con crittografia SSE-KMS da bucket per uso generico a bucket di directory, da bucket di directory a bucket per uso generico o tra bucket di directory, tramite l'operazione [Copy in Operazioni in batch](#directory-buckets-objects-Batch-Ops). In questo caso, Amazon S3 effettua una chiamata AWS KMS ogni volta che viene effettuata una richiesta di copia per un oggetto crittografato con KMS. Per ulteriori informazioni sull'uso di SSE-KMS sui bucket di directory, consulta [Impostazione e monitoraggio della crittografia predefinita per i bucket di directory](s3-express-bucket-encryption.md) e [Utilizzo della crittografia lato server con AWS KMS chiavi (SSE-KMS) nei bucket di directory](s3-express-UsingKMSEncryption.md).
+ Gli oggetti nei bucket di directory non possono essere taggati. Puoi specificare solo un set di tag vuoto. Per impostazione predefinita, Operazioni in batch copia i tag. Se si copia un oggetto che ha dei tag tra i bucket per uso generico e i bucket di directory, si riceve una risposta `501 (Not Implemented)`.
+ S3 Express One Zone offre la possibilità di scegli l'algoritmo di checksum utilizzato per convalidare i dati durante il caricamento o il download. Puoi selezionare uno dei seguenti algoritmi di controllo dell'integrità dei dati Secure Hash Algorithms (SHA) o Cyclic Redundancy Check (CRC):,, SHA-1 e SHA-256. CRC32 CRC32 MD5i checksum basati non sono supportati con la classe di storage S3 Express One Zone.
+ Per impostazione predefinita, tutti i bucket Amazon S3 impostano l'impostazione S3 Object Ownership su bucket owner enforced e le liste di controllo degli accessi () sono disabilitate. ACLs Per i bucket di directory, questa impostazione non può essere modificata. È possibile copiare un oggetto da bucket per uso generico in bucket di directory. Tuttavia, non è possibile sovrascrivere l'ACL predefinita quando si copia da o verso un bucket di directory.
+ A prescindere dalla modalità di specifica del manifesto, l'elenco stesso deve essere archiviato in un bucket per uso generico. Operazioni in batch non può importare manifesti esistenti da (o salvare manifesti generati in) bucket di directory. Tuttavia, gli oggetti descritti all'interno del manifesto possono essere archiviati in bucket di directory.
+ Operazioni in batch non può specificare un bucket di directory come posizione in un report di Inventario S3. I report di inventario non supportano i bucket di directory. È possibile creare un file manifesto per gli oggetti all'interno di un bucket di directory utilizzando l'operazione API `ListObjectsV2` per elencare gli oggetti. È quindi possibile inserire l'elenco in un file CSV.
### Concessione dell'accesso per
Per eseguire processi di copia, è necessario disporre delle autorizzazioni seguenti:
+ Per copiare oggetti da un bucket di directory a un altro, è necessario disporre dell'autorizzazione `s3express:CreateSession`.
+ Per copiare gli oggetti dai bucket di directory ai bucket per uso generico, è necessario disporre dell'autorizzazione `s3express:CreateSession` e dell'autorizzazione `s3:PutObject` per scrivere la copia dell'oggetto nel bucket di destinazione.
+ Per copiare oggetti da bucket per uso generico a bucket di directory, è necessario disporre dei permessi `s3express:CreateSession` e `s3:GetObject` per leggere l'oggetto di origine che si sta copiando.
Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html) in *Amazon Simple Storage Service API Reference* (Guida di riferimento per l'API di Amazon Simple Storage Service).
+ Per richiamare una funzione Lambda, è necessario concedere le autorizzazioni alla risorsa in base alla funzione Lambda. Per determinare quali autorizzazioni sono necessarie, controllare le operazioni API corrispondenti.
# Aggiunta di dati agli oggetti nei bucket della directory
È possibile aggiungere dati alla fine di oggetti esistenti memorizzati nella classe di storage S3 Express One Zone in bucket di directory. Si consiglia di utilizzare la possibilità di aggiungere dati a un oggetto se i dati vengono scritti continuamente per un certo periodo di tempo o se è necessario leggere l'oggetto mentre si sta scrivendo sull'oggetto. L'aggiunta di dati agli oggetti è comune per casi d'uso quali l'aggiunta di nuove voci di log ai file di log o l'aggiunta di nuovi segmenti video ai file video durante la transcodifica e lo streaming. Aggiungendo dati agli oggetti, è possibile semplificare le applicazioni che in precedenza combinavano i dati nell'archiviazione locale prima di copiare l'oggetto finale su Amazon S3.
Non esiste un requisito di dimensione minima per i dati che si possono aggiungere a un oggetto. Tuttavia, la dimensione massima dei dati che si possono aggiungere a un oggetto in una singola richiesta è di 5 GB. Questo è lo stesso limite della dimensione massima della richiesta quando si caricano dati utilizzando qualsiasi API Amazon S3.
Con ogni operazione di aggiunta riuscita, si crea una parte dell'oggetto e ogni oggetto può avere fino a 10.000 parti. Ciò significa che è possibile aggiungere dati a un oggetto fino a 10.000 volte. Se un oggetto viene creato utilizzando il caricamento multiparte S3, ogni parte caricata viene conteggiata nel limite massimo totale di 10.000 parti. Ad esempio, è possibile aggiungere fino a 9.000 volte a un oggetto creato con un caricamento multiparte composto da 1.000 parti.
**Nota**
Se raggiungi il limite di parti, riceverai un [TooManyParts](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html#API_PutObject_Errors)errore. È possibile utilizzare l'API `CopyObject` per azzerare il conteggio.
Se si desidera caricare parti di un oggetto in parallelo e non è necessario leggere le parti mentre vengono caricate, si consiglia di utilizzare il caricamento multiparte di Amazon S3. Per ulteriori informazioni, consulta [Utilizzo del caricamento multiparte](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-using-multipart-upload.html).
L'aggiunta di dati agli oggetti è supportata solo per gli oggetti nei bucket della directory archiviati nella classe di storage S3 Express One Zone. Per ulteriori informazioni su S3 Express One Zone, consulta [Introduzione a S3 Express One Zone](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-getting-started.html).
Per iniziare ad aggiungere dati agli oggetti nei bucket di directory, puoi utilizzare la AWS SDKs AWS CLI e l'API. `PutObject` Quando si effettua una richiesta `PutObject`, si imposta l'intestazione `x-amz-write-offset-bytes` sulla dimensione dell'oggetto a cui si sta aggiungendo. Per utilizzare l'operazione API `PutObject`, è necessario utilizzare l'API `CreateSession` per stabilire credenziali di sicurezza temporanee per accedere agli oggetti nei bucket della directory. Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) e [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateSession.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateSession.html) nella *documentazione di riferimento delle API di Amazon S3*.
Ogni operazione di aggiunta andata a buon fine viene conteggiata come una richiesta di `PutObject`. Per saperne di più sui prezzi, consulta [https://aws.amazon.com/s3/pricing/](https://aws.amazon.com/s3/pricing/).
**Nota**
A partire dalla versione 1.12, Mountpoint per Amazon S3 supporta l'aggiunta di dati agli oggetti memorizzati in S3 Express One Zone. Per iniziare, è necessario effettuare l'opt-in impostando il flag `--incremental-upload `. Per ulteriori informazioni su Mountpoint, consulta [Operazioni con Mountpoint](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mountpoint.html).
Se si utilizza un algoritmo CRC (Cyclic Redundancy Check) durante il caricamento dei dati aggiunti, è possibile recuperare le checksum complete dell'oggetto basate sul CRC utilizzando le richieste `HeadObject` o `GetObject`. Se si utilizza l'algoritmo SHA-1 o SHA-256 durante il caricamento dei dati aggiunti, è possibile recuperare un checksum delle parti aggiunte e verificarne l'integrità utilizzando i checksum SHA restituiti nelle risposte precedenti. PutObject Per ulteriori informazioni, consulta [Protezione dei dati e crittografia](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-data-protection.html.html).
## Aggiungere dati agli oggetti utilizzando la AWS CLI e l'API AWS SDKs REST
Puoi aggiungere dati ai tuoi oggetti utilizzando AWS Command Line Interface (AWS CLI) AWS SDKs e l'API REST.
### Utilizzo della AWS CLI
Il comando di `put-object` esempio seguente mostra come utilizzare la AWS CLI per aggiungere dati a un oggetto. Per eseguire questo comando, sostituiscilo *user input placeholders* con le tue informazioni
```
aws s3api put-object --bucket amzn-s3-demo-bucket--azid--x-s3 --key sampleinput/file001.bin --body bucket-seed/file001.bin --write-offset-bytes size-of-sampleinput/file001.bin
```
### Usando il AWS SDKs
------
#### [ SDK for Java ]
È possibile utilizzare il AWS SDK per Java per aggiungere dati agli oggetti.
```
var putObjectRequestBuilder = PutObjectRequest.builder()
.key(key)
.bucket(bucketName)
.writeOffsetBytes(9);
var response = s3Client.putObject(putObjectRequestBuilder.build());
```
------
#### [ SDK for Python ]
```
s3.put_object(Bucket='amzn-s3-demo-bucket--use2-az2--x-s3', Key='2024-11-05-sdk-test', Body=b'123456789', WriteOffsetBytes=9)
```
------
### Utilizzo della REST API
È possibile inviare richieste REST per aggiungere dati a un oggetto. Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html#API_PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html#API_PutObject).
# Ridenominazione degli oggetti nei bucket di directory
L’operazione `RenameObject` consente di rinominare automaticamente un oggetto esistente in un bucket di directory che utilizza la classe di archiviazione S3 Express One Zone, senza alcun movimento di dati. È possibile rinominare un oggetto specificando il nome dell’oggetto esistente come origine e il nuovo nome dell’oggetto come destinazione all’interno dello stesso bucket di directory. L’operazione API `RenameObject` non ha esito positivo sugli oggetti che terminano con il carattere delimitatore barra (`/`). Per ulteriori informazioni, consulta [Denominazione di oggetti Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html).
L’operazione `RenameObject` viene in genere completata nell’ordine di millisecondi indipendentemente dalla dimensione dell’oggetto. Questa funzionalità accelera applicazioni come la gestione dei file di log, l’elaborazione multimediale e l’analisi dei dati. Inoltre, `RenameObject` conserva tutte le proprietà dei metadati degli oggetti, tra cui la classe di archiviazione, il tipo di crittografia, la data di creazione, la data dell’ultima modifica e le proprietà del checksum.
**Nota**
L’operazione `RenameObject` è supportata solo per gli oggetti archiviati nella classe di archiviazione S3 Express One Zone.
Per fornire l’accesso all’operazione `RenameObject`, è consigliabile utilizzare l’operazione `CreateSession` per l’autorizzazione basata sulla sessione. In particolare, si fornisce l’autorizzazione `s3express:CreateSession` al bucket di directory in una policy di bucket o in una policy basata sull’identità. Quindi, si effettua la chiamata API `CreateSession` sul bucket di directory per ottenere un token di sessione. Con il token di sessione nell’intestazione della richiesta, è possibile effettuare richieste API per questa operazione. Dopo la scadenza del token di sessione, si effettua un’altra chiamata API `CreateSession` per generare un nuovo token di sessione da utilizzare. La AWS CLI e AWS SDKs creerà e gestirà la sessione, incluso l'aggiornamento automatico del token di sessione per evitare interruzioni del servizio alla scadenza di una sessione. Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateSession.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateSession.html) nella *Guida di riferimento delle API di Amazon S3*. Per ulteriori informazioni sulle operazioni API degli endpoint di zona, consulta [Autorizzazione delle operazioni API dell’endpoint di zona con `CreateSession`](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-create-session.html).
Se non desideri sovrascrivere un oggetto esistente, è possibile aggiungere l’intestazione condizionale `If-None-Match` con il valore `‘*’` nella richiesta `RenameObject`. Amazon S3 restituisce un errore `412 Precondition Failed` se il nome dell’oggetto esiste già. Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/AmazonS3/latest/API/API_RenameObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_RenameObject.html) nella *documentazione di riferimento delle API di Amazon S3*.
`RenameObject` è un’operazione API dell’endpoint di zona (operazione a livello di oggetto o piano dati) che viene registrata nel log in AWS CloudTrail. È possibile utilizzare CloudTrail per raccogliere informazioni sull'`RenameObject`operazione eseguita sugli oggetti nei bucket di directory. Per ulteriori informazioni, vedete [Logging with AWS CloudTrail for directory bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-one-zone-logging.html) ed [esempi di file di CloudTrail log per](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-log-files.html) bucket di directory.
S3 Express One Zone è l’unica classe di archiviazione che supporta `RenameObject`, con un prezzo uguale a quello delle richieste `PUT`, `COPY`, `POST` e `LIST` (per 1.000 richieste) in S3 Express One Zone. Per ulteriori informazioni, consulta [Prezzi di Amazon S3](https://aws.amazon.com/s3/pricing/).
## Ridenominazione di un oggetto
Per rinominare un oggetto nel tuo bucket di directory, puoi utilizzare la console Amazon S3, la AWS CLI AWS SDKs, l'API REST o Mountpoint per Amazon S3 (versione 1.19.0 o successiva).
### Utilizzo della console S3
**Come rinominare un oggetto in un bucket di directory**
1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Nel riquadro di navigazione a sinistra, scegli **Bucket**, quindi seleziona la scheda **Bucket di directory**. Passa al bucket di directory Amazon S3 contenente l’oggetto da rinominare.
1. Seleziona la casella di controllo dell'oggetto da rinominare.
1. Nel menu **Azioni**, scegli **Rinomina oggetto**.
1. Nella casella **Nuovo nome oggetto**, inserisci il nuovo nome dell'oggetto.
**Nota**
Se specifichi lo stesso nome di un oggetto esistente, l’operazione ha esito negativo e Amazon S3 restituisce un errore `412 Precondition Failed`. La lunghezza del nome della chiave dell’oggetto non può superare 1.024 byte. I prefissi inclusi nel nome dell’oggetto vengono conteggiati ai fini della lunghezza totale.
1. Scegli **Rinomina l’oggetto**. Amazon S3 rinomina l'oggetto.
### Utilizzo della AWS CLI
Gli esempi `rename-object` illustrano in che modo è possibile utilizzare l’ AWS CLI per rinominare un oggetto. Per eseguire questi comandi, sostituiscili *user input placeholders* con le tue informazioni
L'esempio seguente mostra come rinominare un oggetto con un controllo condizionale sull'oggetto di origine. ETag
```
aws s3api rename-object \
--bucket amzn-s3-demo-bucket--usw2-az1--x-s3 \
--key new-file.txt \
--rename-source original-file.txt \
--source-if-match "\"a1b7c3d2e5f6\""
```
Questo comando funziona nel modo seguente:
+ Rinomina un oggetto da *original-file.txt* a *new-file.txt* nel bucket di directory. *amzn-s3-demo-bucket--usw2-az1--x-s3*
+ Esegue la ridenominazione solo se l'oggetto sorgente ETag corrisponde a "». *a1b7c3d4e5f6*
Se ETag non corrisponde, l'operazione avrà esito negativo e verrà `412 Precondition Failed` generato un errore.
L’esempio seguente mostra come rinominare un oggetto con un controllo condizionale sul nuovo nome dell’oggetto specificato.
```
aws s3api rename-object \
--bucket amzn-s3-demo-bucket--usw2-az1--x-s3 \
--key new-file.txt \
--rename-source amzn-s3-demo-bucket--usw2-az1--x-s3/original-file.txt \
--destination-if-none-match "\"e5f3g7h8i9j0\""
```
Questo comando funziona nel modo seguente:
+ Rinomina un oggetto da *original-file.txt* a *new-file.txt* nel bucket di *amzn-s3-demo-bucket--usw2-az1--x-s3* directory.
+ Esegue l'operazione di ridenominazione solo se l'oggetto esiste e ETag non corrisponde a "». *e5f3g7h8i9j0*
Se esiste già un oggetto con il nuovo nome specificato e la corrispondenza ETag, l'operazione avrà esito negativo e verrà `412 Precondition Failed` generato un errore.
### Usando il AWS SDKs
------
#### [ SDK for Java ]
È possibile utilizzare il AWS SDK per Java per rinominare gli oggetti. Per utilizzare questi esempi, sostituiscili *user input placeholders* con le tue informazioni
L'esempio seguente mostra come creare un file `RenameObjectRequest` utilizzando l' AWS SDK for Java
```
String key = "key";
String newKey = "new-key";
String expectedETag = "e5f3g7h8i9j0";
RenameObjectRequest renameRequest = RenameObjectRequest.builder()
.bucket(amzn-s3-demo-bucket--usw2-az1--x-s3)
.key(newKey)
.renameSource(key)
.destinationIfMatch(e5f3g7h8i9j0)
.build();
```
Il codice effettua le seguenti operazioni:
+ Crea una richiesta per rinominare un oggetto da "" a *key* "*new-key*" nel bucket di directory. *amzn-s3-demo-bucket--usw2-az1--x-s3*
+ Include la condizione che la ridenominazione avvenga solo se l'oggetto ETag corrisponde a "». *e5f3g7h8i9j0*
+ Se ETag non corrisponde o l'oggetto non esiste, l'operazione avrà esito negativo.
L'esempio seguente mostra come creare una condizione `RenameObjectRequest` con una condizione non corrispondente utilizzando l' AWS SDK for Java.
```
String key = "key";
String newKey = "new-key";
String noneMatchETag = "e5f3g7h8i9j0";
RenameObjectRequest renameRequest = RenameObjectRequest.builder()
.bucket(amzn-s3-demo-bucket--usw2-az1--x-s3)
.key(newKey)
.renameSource(key)
.destinationIfNoneMatch(noneMatchETag)
.build();
```
Il codice effettua le seguenti operazioni:
+ Crea una richiesta per rinominare un oggetto da "" a "*key**new-key*" nel bucket di directory. *amzn-s3-demo-bucket--usw2-az1--x-s3*
+ Include una condizione `.destinationIfNoneMatch(noneMatchETag)` che garantisce che la ridenominazione avvenga solo se l'oggetto di destinazione ETag non corrisponde a "». *e5f3g7h8i9j0*
L'operazione fallirà con un `412 Precondition Failed` errore se esiste un oggetto con il nuovo nome specificato e ha quello specificato ETag.
------
#### [ SDK for Python ]
È possibile utilizzare SDK per Python per rinominare gli oggetti. Per utilizzare questi esempi, sostituisci *user input placeholders* con le informazioni appropriate.
L'esempio seguente mostra come rinominare un oggetto utilizzando l' AWS SDK for Python (Boto3).
```
def basic_rename(bucket, source_key, destination_key):
try:
s3.rename_object(
Bucket=amzn-s3-demo-bucket--usw2-az1--x-s3,
Key=destination_key,
RenameSource=f"{source_key}"
)
print(f"Successfully renamed {source_key} to {destination_key}")
except ClientError as e:
print(f"Error renaming object: {e}")
```
Il codice effettua le seguenti operazioni:
+ Rinomina un oggetto da a nel bucket di directory. *source\$1key* *destination\$1key* *amzn-s3-demo-bucket--usw2-az1--x-s3*
+ Stampa un messaggio di esito positivo se la ridenominazione dell’oggetto è stata completata o stampa un messaggio di errore se non è riuscita.
L'esempio seguente mostra come rinominare un oggetto con `DestinationIfNoneMatch` le condizioni `SourceIfMatch` and utilizzando l' AWS SDK for Python (Boto3).
```
def rename_with_conditions(bucket, source_key, destination_key, source_etag, dest_etag):
try:
s3.rename_object(
Bucket=amzn-s3-demo-bucket--usw2-az1--x-s3,
Key=destination_key,
RenameSource=f"{amzn-s3-demo-bucket--usw2-az1--x-s3}/{source_key}",
SourceIfMatch=source_ETag,
DestinationIfNoneMatch=dest_ETag
)
print(f"Successfully renamed {source_key} to {destination_key} with conditions")
except ClientError as e:
print(f"Error renaming object: {e}")
```
Il codice effettua le seguenti operazioni:
+ Esegue un’operazione di ridenominazione condizionale e applica due condizioni, `SourceIfMatch` e `DestinationIfNoneMatch`. La combinazione di queste condizioni assicura che l’oggetto non sia stato modificato e che non esista già un oggetto con il nuovo nome specificato.
+ Rinomina un oggetto da *source\$1key* a nel bucket di directory. *destination\$1key* *amzn-s3-demo-bucket--usw2-az1--x-s3*
+ Stampa un messaggio di esito positivo se la ridenominazione dell’oggetto è stata completata o stampa un messaggio di errore se non è riuscita o se le condizioni non sono soddisfatte.
------
#### [ SDK for Rust ]
È possibile utilizzare SDK per Rust per rinominare gli oggetti. Per utilizzare questi esempi, sostituisci *user input placeholders* con le informazioni appropriate.
L’esempio seguente mostra come rinominare un oggetto nel bucket di directory *amzn-s3-demo-bucket--usw2-az1--x-s3* utilizzando SDK per Rust.
```
async fn basic_rename_example(client: &Client) -> Result<(), Box> {
let response = client
.rename_object()
.bucket(" amzn-s3-demo-bucket--usw2-az1--x-s3")
.key("new-name.txt") // New name/path for the object
.rename_source("old-name.txt") // Original object name/path
.send()
.await?;
Ok(())
}
```
Il codice effettua le seguenti operazioni:
+ Crea una richiesta per rinominare un oggetto da "" a *old-name.tx* "*new-name.txt*" nel bucket di directory. *amzn-s3-demo-bucket--usw2-az1--x-s3*
+ Restituisce un tipo `Result` per gestire potenziali errori.
------
### Utilizzo della REST API
Per rinominare un oggetto è possibile inviare richieste REST. Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/AmazonS3/latest/API/API_RenameObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_RenameObject.html) nella *documentazione di riferimento delle API di Amazon S3*.
### Utilizzo di Mountpoint per Amazon S3
A partire dalla versione 1.19.0 o successiva, Mountpoint per Amazon S3 supporta la ridenominazione degli oggetti in S3 Express One Zone. Per ulteriori informazioni su Mountpoint, consulta [Operazioni con Mountpoint](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mountpoint.html).
# Caricamento di oggetti in un bucket di directory
Dopo aver creato un bucket di directory Amazon S3, è possibile caricarvi oggetti. Gli esempi seguenti mostrano come caricare un oggetto in un bucket di directory utilizzando la console S3 e il. AWS SDKs Per informazioni sulle operazioni di caricamento di oggetti in blocco con S3 Express One Zone, consulta [Gestione degli oggetti](directory-bucket-high-performance.md#s3-express-features-object-management).
## Utilizzo della console S3
1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Nel riquadro di navigazione a sinistra, scegli **Bucket di directory**.
1. Scegli il nome del bucket in cui caricare le cartelle o i file.
1. Nell'elenco **Oggetti**, scegli **Carica**.
1. Nella pagina di **caricamento**, esegui una delle seguenti operazioni:
+ Trascina e rilascia i file e le cartelle nell'area di caricamento tratteggiata.
+ Scegli **Aggiungi file** o **Aggiungi cartella**, scegli i file o le cartelle da caricare, quindi scegli **Apri** o **Carica**.
1. In **Checksum**, scegli la **funzione Checksum** da utilizzare.
(Facoltativo) Se si sta caricando un singolo oggetto di dimensioni inferiori a 16 MB, si può anche specificare un valore di checksum precalcolato. Quando si fornisce un valore precalcolato, Amazon S3 lo confronta con il valore calcolato utilizzando la funzione di checksum selezionata. Se i valori non corrispondono, il caricamento non viene avviato.
1. Le opzioni delle sezioni **Autorizzazioni ** e **Proprietà** sono impostate automaticamente come predefinite e non possono essere modificate. Blocco dell'accesso pubblico è abilitato automaticamente; Controllo delle versioni S3 e S3 Object Lock non possono essere abilitati per i bucket della directory.
(Facoltativo) Se desideri aggiungere metadati in coppie chiave-valore agli oggetti, espandi la sezione **Proprietà** e scegli **Aggiungi metadati** nella sezione **Metadati**.
1. Per caricare i file e le cartelle elencati, scegli **Carica**.
Amazon S3 caricherà i tuoi oggetti e le tue cartelle. Al termine del caricamento viene visualizzato un messaggio di esito positivo nella pagina **Carica: stato**.
## Utilizzando il AWS SDKs
------
#### [ SDK for Java 2.x ]
**Example**
```
public static void putObject(S3Client s3Client, String bucketName, String objectKey, Path filePath) {
//Using File Path to avoid loading the whole file into memory
try {
PutObjectRequest putObj = PutObjectRequest.builder()
.bucket(bucketName)
.key(objectKey)
//.metadata(metadata)
.build();
s3Client.putObject(putObj, filePath);
System.out.println("Successfully placed " + objectKey +" into bucket "+bucketName);
}
catch (S3Exception e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
```
------
#### [ SDK for Python ]
**Example**
```
import boto3
import botocore
from botocore.exceptions import ClientError
def put_object(s3_client, bucket_name, key_name, object_bytes):
"""
Upload data to a directory bucket.
:param s3_client: The boto3 S3 client
:param bucket_name: The bucket that will contain the object
:param key_name: The key of the object to be uploaded
:param object_bytes: The data to upload
"""
try:
response = s3_client.put_object(Bucket=bucket_name, Key=key_name,
Body=object_bytes)
print(f"Upload object '{key_name}' to bucket '{bucket_name}'.")
return response
except ClientError:
print(f"Couldn't upload object '{key_name}' to bucket '{bucket_name}'.")
raise
def main():
# Share the client session with functions and objects to benefit from S3 Express One Zone auth key
s3_client = boto3.client('s3')
# Directory bucket name must end with --zone-id--x-s3
resp = put_object(s3_client, 'doc-bucket-example--use1-az5--x-s3', 'sample.txt', b'Hello, World!')
print(resp)
if __name__ == "__main__":
main()
```
------
## Usando il AWS CLI
Il seguente esempio di comando `put-object` mostra come utilizzare AWS CLI per caricare un oggetto da Amazon S3. Per eseguire questo comando, sostituisci `user input placeholders` con le informazioni appropriate.
```
aws s3api put-object --bucket bucket-base-name--zone-id--x-s3 --key sampleinut/file001.bin --body bucket-seed/file001.bin
```
Per ulteriori informazioni, consulta [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-object.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-object.html) nella *documentazione di riferimento dei comandi della AWS CLI *.
**Topics**
+ [Utilizzo dei caricamenti multiparte con i bucket di directory](s3-express-using-multipart-upload.md)
# Utilizzo dei caricamenti multiparte con i bucket di directory
È possibile utilizzare il processo di caricamento multiparte per caricare un singolo oggetto come un insieme di parti. Ciascuna parte è una parte contigua dei dati dell'oggetto. È possibile caricare queste parti dell'oggetto in modo indipendente e in qualsiasi ordine. Se la trasmissione di una parte non riesce, è possibile ritrasmettere tale parte senza influire sulle altre. Una volta caricate tutte le parti dell'oggetto, Amazon S3 le assembla e crea l'oggetto. In generale, quando la dimensione dell'oggetto raggiunge i 100 MB, si consiglia di valutare la possibilità di eseguire caricamenti in più parti anziché caricare l'oggetto in una singola operazione.
Il caricamento in più parti comporta i vantaggi riportati di seguito.
+ **Throughput migliorato**: puoi caricare le parti in parallelo per migliorare il throughput.
+ **Ripristino rapido da qualsiasi problema di rete** - Le dimensioni ridotte dei pezzi riducono al minimo l'impatto del riavvio di un caricamento fallito a causa di un errore di rete.
+ **Messa in pausa e ripresa dei caricamenti dell'oggetto**: puoi caricare le parti dell'oggetto nel corso del tempo. Dopo aver avviato un caricamento multiparte, non c'è una data di scadenza. È necessario completare o interrompere esplicitamente il caricamento multiparte.
+ **Avvio di un caricamento prima di conoscere la dimensione finale dell'oggetto**: puoi caricare un oggetto mentre viene creato.
Si consiglia di utilizzare i caricamenti multiparte nei seguenti modi:
+ Se si caricano oggetti di grandi dimensioni su una rete stabile ad alta larghezza di banda, utilizzare i caricamenti multiparte per massimizzare l'uso della larghezza di banda disponibile, caricando le parti dell'oggetto in parallelo per ottenere prestazioni multi-thread.
+ Se si sta caricando su una rete discontinua, utilizzare i caricamenti multiparte per aumentare la resilienza agli errori di rete evitando il riavvio del caricamento. Quando si utilizza il caricamento multiparte, è necessario riprovare a caricare solo le parti che si interrompono durante il caricamento. Non è necessario riavviare il caricamento dell'oggetto dall'inizio.
Quando si utilizzano i caricamenti multiparte per caricare oggetti nella classe di storage Amazon S3 Express One Zone in bucket di directory, il processo di caricamento multiparte è simile al processo di caricamento multiparte per caricare oggetti in bucket per uso generico. Tuttavia, non vi sono alcune differenze importanti.
Per ulteriori informazioni sull'uso dei caricamenti multiparte per caricare oggetti su S3 Express One Zone, consulta i seguenti argomenti.
**Topics**
+ [Il processo di caricamento multiparte](#s3-express-mpu-process)
+ [Checksum con operazioni di caricamento in più parti](#s3-express-mpuchecksums)
+ [Operazioni simultanee di caricamento in più parti](#s3-express-distributedmpupload)
+ [Caricamenti multiparte e prezzi](#s3-express-mpuploadpricing)
+ [Operazioni e autorizzazioni dell'API per il caricamento multiparte](#s3-express-mpuAndPermissions)
+ [Esempi](#directory-buckets-multipart-upload-examples)
## Il processo di caricamento multiparte
Un caricamento multiparte è un processo in tre fasi:
+ L'utente avvia il caricamento.
+ Si caricano le parti dell'oggetto.
+ Dopo aver caricato tutte le parti, si completa il caricamento multiparte.
Una volta ricevuta la richiesta di caricamento multiparte completa, Amazon S3 costruisce l'oggetto dalle parti caricate e l'utente può quindi accedere all'oggetto come a qualsiasi altro oggetto nel bucket.
**Avvio del caricamento in più parti**
Quando invii una richiesta di avvio di un caricamento in più parti, Amazon S3 restituisce una risposta con un ID di caricamento, che è un identificativo univoco per il caricamento in più parti. È necessario includere questo ID di caricamento ogni volta che si caricano o si elencano le parti oppure ogni volta che si completa o si interrompe un caricamento.
**Caricamento delle parti**
Quando si carica una parte, oltre all'ID di caricamento è necessario specificare il numero della parte. Quando si utilizza un caricamento multiparte con S3 Express One Zone, i numeri di parte multiparte devono essere numeri di parte consecutivi. Se si tenta di completare una richiesta di caricamento multiparte con numeri di parte non consecutivi, viene generato un errore `HTTP 400 Bad Request` (Invalid Part Order).
Un numero di parte identifica in modo univoco una parte e la sua posizione nell'oggetto che si sta caricando. Se si carica una nuova parte utilizzando lo stesso numero di parte di una parte caricata in precedenza, la parte caricata in precedenza viene sovrascritta.
Ogni volta che carichi una parte, Amazon S3 restituisce un'intestazione entity tag (ETag) nella sua risposta. Per ogni caricamento di una parte, devi registrare il numero e il valore della ETag parte. I ETag valori per tutti i caricamenti di parti di oggetti rimarranno gli stessi, ma a ciascuna parte verrà assegnato un numero di parte diverso. Occorre includere questi valori nella successiva richiesta di complemento del caricamento in più parti.
Amazon S3 esegue automaticamente la crittografa di tutti i nuovi oggetti caricati in un bucket S3. Quando si esegue un caricamento in più parti, se non si specificano le informazioni di crittografia nella richiesta, l'impostazione di crittografia delle parti caricate viene impostata sulla configurazione di crittografia predefinita del bucket di destinazione. La configurazione di crittografia predefinita di un bucket Amazon S3 è sempre abilitata ed è impostata come minimo sulla crittografia lato server con chiavi gestite da Amazon S3 (SSE-S3). Per i bucket di directory, sono supportati SSE-S3 e la crittografia con AWS KMS chiavi lato server (SSE-KMS). Per ulteriori informazioni, consulta [Protezione e crittografia dei dati](s3-express-data-protection.md).
**Completamento del caricamento in più parti**
Quando si completa un caricamento multiparte, Amazon S3 crea l'oggetto concatenando le parti in ordine crescente in base al numero di parte. Una volta *completata* la richiesta, le parti non esisteranno più.
La richiesta di caricamento *multiparte completa deve includere l'ID di caricamento* e un elenco di entrambi i numeri di parte e i valori corrispondenti. ETag La risposta di Amazon S3 include un codice ETag che identifica in modo univoco i dati combinati dell'oggetto. Questo non ETag è un MD5 hash dei dati dell'oggetto.
**Elenchi dei caricamenti in più parti**
È possibile elencare le parti di un caricamento in più parti specifico o tutti i caricamenti in più parti in corso. L'operazione di creazione dell'elenco delle parti restituisce informazioni sulle parti coinvolte in un caricamento in più parti specifico. Per ogni richiesta di elenco delle parti, Amazon S3 restituisce informazioni sulle parti per il caricamento in più parti specificato, fino a un massimo di 1000 parti. Se nel caricamento in più parti sono presenti più di 1000 parti, è necessario utilizzare la paginazione per recuperare tutte le parti.
L'elenco di parti restituite non include quelle che non hanno terminato il caricamento. L'operazione *list multipart uploads (elenco dei caricamenti in più parti)* consente di ottenere l'elenco dei caricamenti in più parti in corso.
Un caricamento in più parti in corso è un caricamento avviato, ma non ancora completato o annullato. Ogni richiesta restituisce al massimo 1.000 caricamenti in più parti. Se sono in corso più di 1.000 caricamenti in più parti, è necessario inviare richieste aggiuntive per recuperare i caricamenti rimanenti. Utilizza l'elenco restituito solo per la verifica. Non utilizzarlo per inviare la richiesta *complete multipart upload (completamento del caricamento in più parti)*. Gestisci invece il tuo elenco dei codici articolo che hai specificato durante il caricamento delle parti e i ETag valori corrispondenti restituiti da Amazon S3.
Per ulteriori informazioni sugli elenchi di caricamento multiparte, consulta [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html) in *Riferimento API di Amazon Simple Storage Service*.
## Checksum con operazioni di caricamento in più parti
Quando carichi un oggetto su, puoi specificare un algoritmo di checksum per verificare l'integrità dell'oggetto. MD5 non è supportato per i bucket di directory. È possibile specificare uno dei seguenti algoritmi di controllo dell'integrità dei dati Secure Hash Algorithms (SHA) o Cyclic Redundancy Check (CRC):
+ CRC32
+ CRC32C
+ SHA-1
+ SHA-256
Puoi utilizzare l'API REST di Amazon S3 o AWS SDKs recuperare il valore del checksum per singole parti utilizzando o. `GetObject` `HeadObject` Se desideri recuperare i valori di checksum per singole parti di caricamenti in più parti ancora in corso, puoi utilizzare `ListParts`.
**Importante**
Quando si utilizzano i precedenti algoritmi di checksum, i numeri di parte multiparte devono utilizzare numeri di parte consecutivi. Se si tenta di completare una richiesta di caricamento multiparte con numeri di parte non consecutivi, Amazon S3 genera un errore `HTTP 400 Bad Request` (Invalid Part Order).
Per ulteriori informazioni sul funzionamento dei checksum con gli oggetti di caricamento multiparte, consulta [Verifica dell'integrità degli oggetti in Amazon S3](checking-object-integrity.md).
## Operazioni simultanee di caricamento in più parti
In un ambiente di sviluppo distribuito, l'applicazione può avviare diversi aggiornamenti sullo stesso oggetto nello stesso momento. Ad esempio, l'applicazione potrebbe avviare diversi caricamenti multiparte utilizzando la stessa chiave oggetto. Per ciascuno di questi caricamenti, l'applicazione può quindi caricare le parti e inviare una richiesta di completamento del caricamento ad Amazon S3 per creare l'oggetto. Per S3 Express One Zone, l'ora di creazione dell'oggetto è la data di completamento del caricamento in più parti.
**Importante**
Il controllo delle versioni non è supportato per gli oggetti memorizzati nei bucket della directory.
## Caricamenti multiparte e prezzi
Una volta avviato un caricamento in più parti, Amazon S3 mantiene tutte le parti finché il caricamento non viene completato o interrotto. Per tutta la durata del processo, all'utente vengono fatturati i costi per lo storage, la larghezza di banda e le richieste per questo tipo di caricamento e per le parti associate. Se si interrompe il caricamento multiparte, Amazon S3 elimina gli artefatti di caricamento e tutte le parti caricate e non vengono più addebitate. Non sono previsti costi di cancellazione anticipata per l'eliminazione di caricamenti multiparte incompleti, indipendentemente dalla classe di storage specificata. Per ulteriori informazioni sui prezzi, consulta [Prezzi di Amazon S3](https://aws.amazon.com/s3/pricing/).
**Importante**
Se la richiesta completa di caricamento multiparte non viene inviata con successo, le parti dell'oggetto non vengono assemblate e non viene creato un oggetto. Ti viene addebitato tutto lo spazio di storage associato alle parti caricate. È importante completare il caricamento multiparte per creare l'oggetto o interrompere il caricamento multiparte per rimuovere le parti caricate.
Prima di eliminare un bucket di directory, è necessario completare o interrompere tutti i caricamenti multiparte in corso. I bucket di directory non supportano le configurazioni di S3 Lifecycle. Se necessario, è possibile elencare i caricamenti multiparte attivi, quindi interrompere i caricamenti e cancellare il bucket.
## Operazioni e autorizzazioni dell'API per il caricamento multiparte
Per consentire l'accesso alle operazioni API di gestione degli oggetti su un bucket di directory, si concede l'autorizzazione `s3express:CreateSession` in una policy di bucket o in una policy basata sull'identità AWS Identity and Access Management (IAM).
Per eseguire le operazioni di caricamento in più parti, devi disporre delle autorizzazioni necessarie. È possibile utilizzare le policy dei bucket o le policy basate sull'identità IAM per concedere ai principali IAM le autorizzazioni per eseguire le operazioni. Nella tabella riportata di seguito sono elencate le autorizzazioni richieste per le varie operazioni di caricamento in più parti.
È possibile identificare l'iniziatore di un caricamento multiparte tramite l'elemento `Initiator`. Se l'iniziatore è un Account AWS, questo elemento fornisce le stesse informazioni dell'elemento. `Owner` Se è un utente IAM, questo elemento fornisce l'ARN e il nome visualizzato dell'utente.
| Azione | Autorizzazioni richieste |
| --- | --- |
| Creazione di un caricamento in più parti | Per creare il caricamento multiparte, è necessario essere autorizzati a eseguire l'azione `s3express:CreateSession` sul bucket della directory. |
| Avvio di un caricamento multiparte | Per avviare il caricamento multiparte, è necessario essere autorizzati a eseguire l'azione `s3express:CreateSession` sul bucket della directory. |
| Caricamento di una parte | Per caricare una parte, è necessario essere autorizzati a eseguire l'azione `s3express:CreateSession` sul bucket della directory. Affinché l'iniziatore possa caricare una parte, il proprietario del bucket deve consentire all'iniziatore di eseguire l'azione `s3express:CreateSession` sul bucket della directory. |
| Caricamento di una parte (copia) | Per caricare una parte, è necessario essere autorizzati a eseguire l'azione `s3express:CreateSession` sul bucket della directory. Perché l'iniziatore possa caricare una parte di un oggetto, il proprietario del bucket deve consentire all'iniziatore di eseguire l'operazione `s3express:CreateSession` sull'oggetto. |
| Completamento del caricamento in più parti | Per completare un caricamento multiparte, è necessario essere autorizzati a eseguire l'azione `s3express:CreateSession` sul bucket della directory. Affinché l'iniziatore completi un caricamento multiparte, il proprietario del bucket deve consentire all'iniziatore di eseguire l'azione `s3express:CreateSession` sull'oggetto. |
| Interrompere un caricamento in più parti | Per interrompere un caricamento multiparte, è necessario essere autorizzati a eseguire l'azione `s3express:CreateSession`. Affinché l'iniziatore possa interrompere un caricamento multiparte, è necessario che gli venga concesso l'accesso esplicito per eseguire l'azione `s3express:CreateSession`. |
| Elenco di parti | Per elencare le parti in un caricamento multiparte, è necessario essere autorizzati a eseguire l'azione `s3express:CreateSession` sul bucket della directory. |
| Elenco di caricamenti in più parti in corso | Per elencare i caricamenti multiparte in corso su un bucket, è necessario essere autorizzati a eseguire l'azione `s3:ListBucketMultipartUploads` su quel bucket. |
### Supporto delle operazioni API per il caricamento multiparte
Le seguenti sezioni della Riferimento API di Amazon Simple Storage Service descrivono il funzionamento della REST API di Amazon S3 per il caricamento multiparte.
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html)
## Esempi
Per utilizzare un caricamento multiparte per caricare un oggetto su S3 Express One Zone in un bucket di directory, consulta gli esempi seguenti.
**Topics**
+ [Creazione di un caricamento in più parti](#directory-buckets-multipart-upload-examples-create)
+ [Caricamento delle parti di un caricamento multiparte](#directory-buckets-multipart-upload-examples-upload-part)
+ [Completamento di un caricamento in più parti](#directory-buckets-multipart-upload-examples-complete)
+ [Interruzione di un caricamento in più parti](#directory-buckets-multipart-upload-examples-abort)
+ [Creazione di un'operazione di copia di caricamento in più parti](#directory-buckets-multipart-upload-examples-upload-part-copy)
+ [Elenco dei caricamenti multiparte in corso](#directory-buckets-multipart-upload-examples-list)
+ [Elenco di parti di un caricamento multiparte](#directory-buckets-multipart-upload-examples-list-parts)
### Creazione di un caricamento in più parti
**Nota**
Per i bucket di directory, quando si esegue un'operazione `CreateMultipartUpload` e un'operazione `UploadPartCopy`, la crittografia predefinita del bucket deve utilizzare la configurazione di crittografia desiderata e le intestazioni di richiesta fornite nella richiesta `CreateMultipartUpload` devono corrispondere alla configurazione di crittografia predefinita del bucket di destinazione.
Gli esempi seguenti mostrano come creare un caricamento multiparte.
#### Usando il AWS SDKs
------
#### [ SDK for Java 2.x ]
**Example**
```
/**
* This method creates a multipart upload request that generates a unique upload ID that is used to track
* all the upload parts
*
* @param s3
* @param bucketName - for example, 'doc-example-bucket--use1-az4--x-s3'
* @param key
* @return
*/
private static String createMultipartUpload(S3Client s3, String bucketName, String key) {
CreateMultipartUploadRequest createMultipartUploadRequest = CreateMultipartUploadRequest.builder()
.bucket(bucketName)
.key(key)
.build();
String uploadId = null;
try {
CreateMultipartUploadResponse response = s3.createMultipartUpload(createMultipartUploadRequest);
uploadId = response.uploadId();
}
catch (S3Exception e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
return uploadId;
```
------
#### [ SDK for Python ]
**Example**
```
def create_multipart_upload(s3_client, bucket_name, key_name):
'''
Create a multipart upload to a directory bucket
:param s3_client: boto3 S3 client
:param bucket_name: The destination bucket for the multipart upload
:param key_name: The key name for the object to be uploaded
:return: The UploadId for the multipart upload if created successfully, else None
'''
try:
mpu = s3_client.create_multipart_upload(Bucket = bucket_name, Key = key_name)
return mpu['UploadId']
except ClientError as e:
logging.error(e)
return None
```
------
#### Usando il AWS CLI
Questo esempio mostra come creare un upload multiparte su un bucket di directory utilizzando il metodo AWS CLI. Questo comando avvia un caricamento multiparte nel bucket di directory *bucket-base-name* -- *zone-id* --x-s3 per l'oggetto. *KEY\$1NAME* Per utilizzare il comando, sostituiscilo con le tue informazioni*user input placeholders*.
```
aws s3api create-multipart-upload --bucket bucket-base-name--zone-id--x-s3 --key KEY_NAME
```
Per ulteriori informazioni, consulta [create-multipart-upload](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/create-multipart-upload.html) nella AWS Command Line Interface.
### Caricamento delle parti di un caricamento multiparte
Gli esempi seguenti mostrano come caricare parti di un caricamento multiparte.
#### Usando il AWS SDKs
------
#### [ SDK for Java 2.x ]
L'esempio seguente mostra come suddividere un singolo oggetto in parti e quindi caricare tali parti in un bucket di directory utilizzando l'SDK per Java 2.x.
**Example**
```
/**
* This method creates part requests and uploads individual parts to S3 and then returns all the completed parts
*
* @param s3
* @param bucketName
* @param key
* @param uploadId
* @throws IOException
*/
private static ListCompletedPartmultipartUpload(S3Client s3, String bucketName, String key, String uploadId, String filePath) throws IOException {
int partNumber = 1;
ListCompletedPart completedParts = new ArrayList<>();
ByteBuffer bb = ByteBuffer.allocate(1024 * 1024 * 5); // 5 MB byte buffer
// read the local file, breakdown into chunks and process
try (RandomAccessFile file = new RandomAccessFile(filePath, "r")) {
long fileSize = file.length();
int position = 0;
while (position < fileSize) {
file.seek(position);
int read = file.getChannel().read(bb);
bb.flip(); // Swap position and limit before reading from the buffer.
UploadPartRequest uploadPartRequest = UploadPartRequest.builder()
.bucket(bucketName)
.key(key)
.uploadId(uploadId)
.partNumber(partNumber)
.build();
UploadPartResponse partResponse = s3.uploadPart(
uploadPartRequest,
RequestBody.fromByteBuffer(bb));
CompletedPart part = CompletedPart.builder()
.partNumber(partNumber)
.eTag(partResponse.eTag())
.build();
completedParts.add(part);
bb.clear();
position += read;
partNumber++;
}
}
catch (IOException e) {
throw e;
}
return completedParts;
}
```
------
#### [ SDK for Python ]
L'esempio seguente mostra come suddividere un singolo oggetto in parti e quindi caricare tali parti in un bucket di directory utilizzando l'SDK per Python.
**Example**
```
def multipart_upload(s3_client, bucket_name, key_name, mpu_id, part_size):
'''
Break up a file into multiple parts and upload those parts to a directory bucket
:param s3_client: boto3 S3 client
:param bucket_name: Destination bucket for the multipart upload
:param key_name: Key name for object to be uploaded and for the local file that's being uploaded
:param mpu_id: The UploadId returned from the create_multipart_upload call
:param part_size: The size parts that the object will be broken into, in bytes.
Minimum 5 MiB, Maximum 5 GiB. There is no minimum size for the last part of your multipart upload.
:return: part_list for the multipart upload if all parts are uploaded successfully, else None
'''
part_list = []
try:
with open(key_name, 'rb') as file:
part_counter = 1
while True:
file_part = file.read(part_size)
if not len(file_part):
break
upload_part = s3_client.upload_part(
Bucket = bucket_name,
Key = key_name,
UploadId = mpu_id,
Body = file_part,
PartNumber = part_counter
)
part_list.append({'PartNumber': part_counter, 'ETag': upload_part['ETag']})
part_counter += 1
except ClientError as e:
logging.error(e)
return None
return part_list
```
------
#### Usando il AWS CLI
Questo esempio mostra come suddividere un singolo oggetto in parti e quindi caricare tali parti in un bucket di directory, utilizzando il metodo AWS CLI. Per utilizzare il comando sostituiscili *user input placeholders* con le tue informazioni.
```
aws s3api upload-part --bucket bucket-base-name--zone-id--x-s3 --key KEY_NAME --part-number 1 --body LOCAL_FILE_NAME --upload-id "AS_mgt9RaQE9GEaifATue15dAAAAAAAAAAEMAAAAAAAAADQwNzI4MDU0MjUyMBYAAAAAAAAAAA0AAAAAAAAAAAH2AfYAAAAAAAAEBSD0WBKMAQAAAABneY9yBVsK89iFkvWdQhRCcXohE8RbYtc9QvBOG8tNpA"
```
Per ulteriori informazioni, consulta [upload-part](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/upload-part.html) in AWS Command Line Interface.
### Completamento di un caricamento in più parti
Gli esempi seguenti mostrano come completare un caricamento multiparte.
#### Usando il AWS SDKs
------
#### [ SDK for Java 2.x ]
Gli esempi che seguono mostrano come completare un caricamento multiparte utilizzando l'SDK per Java 2.x.
**Example**
```
/**
* This method completes the multipart upload request by collating all the upload parts
* @param s3
* @param bucketName - for example, 'doc-example-bucket--usw2-az1--x-s3'
* @param key
* @param uploadId
* @param uploadParts
*/
private static void completeMultipartUpload(S3Client s3, String bucketName, String key, String uploadId, ListCompletedPart uploadParts) {
CompletedMultipartUpload completedMultipartUpload = CompletedMultipartUpload.builder()
.parts(uploadParts)
.build();
CompleteMultipartUploadRequest completeMultipartUploadRequest =
CompleteMultipartUploadRequest.builder()
.bucket(bucketName)
.key(key)
.uploadId(uploadId)
.multipartUpload(completedMultipartUpload)
.build();
s3.completeMultipartUpload(completeMultipartUploadRequest);
}
public static void multipartUploadTest(S3Client s3, String bucketName, String key, String localFilePath) {
System.out.println("Starting multipart upload for: " + key);
try {
String uploadId = createMultipartUpload(s3, bucketName, key);
System.out.println(uploadId);
ListCompletedPart parts = multipartUpload(s3, bucketName, key, uploadId, localFilePath);
completeMultipartUpload(s3, bucketName, key, uploadId, parts);
System.out.println("Multipart upload completed for: " + key);
}
catch (Exception e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
```
------
#### [ SDK for Python ]
Gli esempi che seguono mostrano come completare un caricamento multiparte utilizzando l'SDK per Python.
**Example**
```
def complete_multipart_upload(s3_client, bucket_name, key_name, mpu_id, part_list):
'''
Completes a multipart upload to a directory bucket
:param s3_client: boto3 S3 client
:param bucket_name: The destination bucket for the multipart upload
:param key_name: The key name for the object to be uploaded
:param mpu_id: The UploadId returned from the create_multipart_upload call
:param part_list: The list of uploaded part numbers with their associated ETags
:return: True if the multipart upload was completed successfully, else False
'''
try:
s3_client.complete_multipart_upload(
Bucket = bucket_name,
Key = key_name,
UploadId = mpu_id,
MultipartUpload = {
'Parts': part_list
}
)
except ClientError as e:
logging.error(e)
return False
return True
if __name__ == '__main__':
MB = 1024 ** 2
region = 'us-west-2'
bucket_name = 'BUCKET_NAME'
key_name = 'OBJECT_NAME'
part_size = 10 * MB
s3_client = boto3.client('s3', region_name = region)
mpu_id = create_multipart_upload(s3_client, bucket_name, key_name)
if mpu_id is not None:
part_list = multipart_upload(s3_client, bucket_name, key_name, mpu_id, part_size)
if part_list is not None:
if complete_multipart_upload(s3_client, bucket_name, key_name, mpu_id, part_list):
print (f'{key_name} successfully uploaded through a ultipart upload to {bucket_name}')
else:
print (f'Could not upload {key_name} hrough a multipart upload to {bucket_name}')
```
------
#### Usando il AWS CLI
Questo esempio mostra come completare un caricamento multiparte per un bucket di directory utilizzando il comando AWS CLI. Per utilizzare il comando sostituiscili *user input placeholders* con le tue informazioni.
```
aws s3api complete-multipart-upload --bucket bucket-base-name--zone-id--x-s3 --key KEY_NAME --upload-id "AS_mgt9RaQE9GEaifATue15dAAAAAAAAAAEMAAAAAAAAADQwNzI4MDU0MjUyMBYAAAAAAAAAAA0AAAAAAAAAAAH2AfYAAAAAAAAEBSD0WBKMAQAAAABneY9yBVsK89iFkvWdQhRCcXohE8RbYtc9QvBOG8tNpA" --multipart-upload file://parts.json
```
Questo esempio prende una struttura JSON che descrive le parti del caricamento multiparte che devono essere riassemblate nel file completo. In questo esempio, il prefisso `file://` è usato per caricare la struttura JSON da un file nella cartella locale chiamato `parts`.
parts.json:
```
parts.json
{
"Parts": [
{
"ETag": "6b78c4a64dd641a58dac8d9258b88147",
"PartNumber": 1
}
]
}
```
Per ulteriori informazioni, consulta [complete-multipart-upload](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/complete-multipart-upload.html) nella AWS Command Line Interface.
### Interruzione di un caricamento in più parti
Gli esempi seguenti mostrano come interrompere un caricamento multiparte.
#### Usando il AWS SDKs
------
#### [ SDK for Java 2.x ]
L'esempio seguente mostra come interrompere un caricamento multiparte utilizzando l'SDK per Java 2.x.
**Example**
```
public static void abortMultiPartUploads( S3Client s3, String bucketName ) {
try {
ListMultipartUploadsRequest listMultipartUploadsRequest = ListMultipartUploadsRequest.builder()
.bucket(bucketName)
.build();
ListMultipartUploadsResponse response = s3.listMultipartUploads(listMultipartUploadsRequest);
ListMultipartUpload uploads = response.uploads();
AbortMultipartUploadRequest abortMultipartUploadRequest;
for (MultipartUpload upload: uploads) {
abortMultipartUploadRequest = AbortMultipartUploadRequest.builder()
.bucket(bucketName)
.key(upload.key())
.uploadId(upload.uploadId())
.build();
s3.abortMultipartUpload(abortMultipartUploadRequest);
}
}
catch (S3Exception e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
```
------
#### [ SDK for Python ]
L'esempio seguente mostra come interrompere un caricamento multiparte utilizzando l'SDK per Python.
**Example**
```
import logging
import boto3
from botocore.exceptions import ClientError
def abort_multipart_upload(s3_client, bucket_name, key_name, upload_id):
'''
Aborts a partial multipart upload in a directory bucket.
:param s3_client: boto3 S3 client
:param bucket_name: Bucket where the multipart upload was initiated - for example, 'doc-example-bucket--usw2-az1--x-s3'
:param key_name: Name of the object for which the multipart upload needs to be aborted
:param upload_id: Multipart upload ID for the multipart upload to be aborted
:return: True if the multipart upload was successfully aborted, False if not
'''
try:
s3_client.abort_multipart_upload(
Bucket = bucket_name,
Key = key_name,
UploadId = upload_id
)
except ClientError as e:
logging.error(e)
return False
return True
if __name__ == '__main__':
region = 'us-west-2'
bucket_name = 'BUCKET_NAME'
key_name = 'KEY_NAME'
upload_id = 'UPLOAD_ID'
s3_client = boto3.client('s3', region_name = region)
if abort_multipart_upload(s3_client, bucket_name, key_name, upload_id):
print (f'Multipart upload for object {key_name} in {bucket_name} bucket has been aborted')
else:
print (f'Unable to abort multipart upload for object {key_name} in {bucket_name} bucket')
```
------
#### Usando il AWS CLI
L'esempio seguente mostra come interrompere un caricamento multiparte utilizzando AWS CLI. Per utilizzare il comando sostituiscili *user input placeholders* con le tue informazioni.
```
aws s3api abort-multipart-upload --bucket bucket-base-name--zone-id--x-s3 --key KEY_NAME --upload-id "AS_mgt9RaQE9GEaifATue15dAAAAAAAAAAEMAAAAAAAAADQwNzI4MDU0MjUyMBYAAAAAAAAAAA0AAAAAAAAAAAH2AfYAAAAAAAAEAX5hFw-MAQAAAAB0OxUFeA7LTbWWFS8WYwhrxDxTIDN-pdEEq_agIHqsbg"
```
Per ulteriori informazioni, consulta [abort-multipart-upload](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/abort-multipart-upload.html) nella AWS Command Line Interface.
### Creazione di un'operazione di copia di caricamento in più parti
**Nota**
Per crittografare le nuove copie di parti di oggetti in un bucket di directory con SSE-KMS, è necessario specificare SSE-KMS come configurazione di crittografia predefinita del bucket di directory con una chiave KMS (in particolare, una [chiave gestita dal cliente](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk)). [Chiave gestita da AWS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk) (`aws/s3`) non è supportato. La configurazione di SSE-KMS può supportare solo 1 [chiave gestita dal cliente](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk) per ogni bucket di directory per tutta la durata del bucket. Dopo aver specificato una chiave gestita dal cliente per SSE-KMS, non è possibile sovrascrivere la chiave gestita dal cliente per la configurazione SSE-KMS del bucket. Non è possibile specificare le impostazioni di crittografia sul lato server per le nuove copie di parti di oggetti con SSE-KMS nelle intestazioni della richiesta. [UploadPartCopy](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html) Inoltre, le intestazioni della richiesta fornite nella richiesta `CreateMultipartUpload` devono corrispondere alla configurazione di crittografia predefinita del bucket di destinazione.
Le chiavi dei bucket S3 non sono supportate quando si copiano oggetti con crittografia SSE-KMS da bucket per uso generico a bucket di directory, da bucket di directory a bucket per uso generico o tra bucket di directory, tramite [https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html). In questo caso, Amazon S3 effettua una chiamata AWS KMS ogni volta che viene effettuata una richiesta di copia per un oggetto crittografato con KMS.
Gli esempi seguenti mostrano come copiare gli oggetti da un bucket a un altro utilizzando un caricamento multiparte.
#### Usando il AWS SDKs
------
#### [ SDK for Java 2.x ]
L'esempio seguente mostra come utilizzare un caricamento multiparte per copiare programmaticamente un oggetto da un bucket all'altro, utilizzando l'SDK per Java 2.x.
**Example**
```
/**
* This method creates a multipart upload request that generates a unique upload ID that is used to track
* all the upload parts.
*
* @param s3
* @param bucketName
* @param key
* @return
*/
private static String createMultipartUpload(S3Client s3, String bucketName, String key) {
CreateMultipartUploadRequest createMultipartUploadRequest = CreateMultipartUploadRequest.builder()
.bucket(bucketName)
.key(key)
.build();
String uploadId = null;
try {
CreateMultipartUploadResponse response = s3.createMultipartUpload(createMultipartUploadRequest);
uploadId = response.uploadId();
} catch (S3Exception e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
return uploadId;
}
/**
* Creates copy parts based on source object size and copies over individual parts
*
* @param s3
* @param sourceBucket
* @param sourceKey
* @param destnBucket
* @param destnKey
* @param uploadId
* @return
* @throws IOException
*/
public static ListCompletedPart multipartUploadCopy(S3Client s3, String sourceBucket, String sourceKey, String destnBucket, String destnKey, String uploadId) throws IOException {
// Get the object size to track the end of the copy operation.
HeadObjectRequest headObjectRequest = HeadObjectRequest
.builder()
.bucket(sourceBucket)
.key(sourceKey)
.build();
HeadObjectResponse response = s3.headObject(headObjectRequest);
Long objectSize = response.contentLength();
System.out.println("Source Object size: " + objectSize);
// Copy the object using 20 MB parts.
long partSize = 20 * 1024 * 1024;
long bytePosition = 0;
int partNum = 1;
ListCompletedPart completedParts = new ArrayList<>();
while (bytePosition < objectSize) {
// The last part might be smaller than partSize, so check to make sure
// that lastByte isn't beyond the end of the object.
long lastByte = Math.min(bytePosition + partSize - 1, objectSize - 1);
System.out.println("part no: " + partNum + ", bytePosition: " + bytePosition + ", lastByte: " + lastByte);
// Copy this part.
UploadPartCopyRequest req = UploadPartCopyRequest.builder()
.uploadId(uploadId)
.sourceBucket(sourceBucket)
.sourceKey(sourceKey)
.destinationBucket(destnBucket)
.destinationKey(destnKey)
.copySourceRange("bytes="+bytePosition+"-"+lastByte)
.partNumber(partNum)
.build();
UploadPartCopyResponse res = s3.uploadPartCopy(req);
CompletedPart part = CompletedPart.builder()
.partNumber(partNum)
.eTag(res.copyPartResult().eTag())
.build();
completedParts.add(part);
partNum++;
bytePosition += partSize;
}
return completedParts;
}
public static void multipartCopyUploadTest(S3Client s3, String srcBucket, String srcKey, String destnBucket, String destnKey) {
System.out.println("Starting multipart copy for: " + srcKey);
try {
String uploadId = createMultipartUpload(s3, destnBucket, destnKey);
System.out.println(uploadId);
ListCompletedPart parts = multipartUploadCopy(s3, srcBucket, srcKey,destnBucket, destnKey, uploadId);
completeMultipartUpload(s3, destnBucket, destnKey, uploadId, parts);
System.out.println("Multipart copy completed for: " + srcKey);
} catch (Exception e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
```
------
#### [ SDK for Python ]
L'esempio seguente mostra come utilizzare un caricamento multiparte per copiare programmaticamente un oggetto da un bucket a un altro, utilizzando l'SDK per Python.
**Example**
```
import logging
import boto3
from botocore.exceptions import ClientError
def head_object(s3_client, bucket_name, key_name):
'''
Returns metadata for an object in a directory bucket
:param s3_client: boto3 S3 client
:param bucket_name: Bucket that contains the object to query for metadata
:param key_name: Key name to query for metadata
:return: Metadata for the specified object if successful, else None
'''
try:
response = s3_client.head_object(
Bucket = bucket_name,
Key = key_name
)
return response
except ClientError as e:
logging.error(e)
return None
def create_multipart_upload(s3_client, bucket_name, key_name):
'''
Create a multipart upload to a directory bucket
:param s3_client: boto3 S3 client
:param bucket_name: Destination bucket for the multipart upload
:param key_name: Key name of the object to be uploaded
:return: UploadId for the multipart upload if created successfully, else None
'''
try:
mpu = s3_client.create_multipart_upload(Bucket = bucket_name, Key = key_name)
return mpu['UploadId']
except ClientError as e:
logging.error(e)
return None
def multipart_copy_upload(s3_client, source_bucket_name, key_name, target_bucket_name, mpu_id, part_size):
'''
Copy an object in a directory bucket to another bucket in multiple parts of a specified size
:param s3_client: boto3 S3 client
:param source_bucket_name: Bucket where the source object exists
:param key_name: Key name of the object to be copied
:param target_bucket_name: Destination bucket for copied object
:param mpu_id: The UploadId returned from the create_multipart_upload call
:param part_size: The size parts that the object will be broken into, in bytes.
Minimum 5 MiB, Maximum 5 GiB. There is no minimum size for the last part of your multipart upload.
:return: part_list for the multipart copy if all parts are copied successfully, else None
'''
part_list = []
copy_source = {
'Bucket': source_bucket_name,
'Key': key_name
}
try:
part_counter = 1
object_size = head_object(s3_client, source_bucket_name, key_name)
if object_size is not None:
object_size = object_size['ContentLength']
while (part_counter - 1) * part_size
L'esempio seguente mostra come utilizzare un caricamento multiparte per copiare programmaticamente un oggetto da un bucket a un bucket della directory, utilizzando AWS CLI. Per utilizzare il comando sostituiscili *user input placeholders* con le tue informazioni.
```
aws s3api upload-part-copy --bucket bucket-base-name--zone-id--x-s3 --key TARGET_KEY_NAME --copy-source SOURCE_BUCKET_NAME/SOURCE_KEY_NAME --part-number 1 --upload-id "AS_mgt9RaQE9GEaifATue15dAAAAAAAAAAEMAAAAAAAAADQwNzI4MDU0MjUyMBYAAAAAAAAAAA0AAAAAAAAAAAH2AfYAAAAAAAAEBnJ4cxKMAQAAAABiNXpOFVZJ1tZcKWib9YKE1C565_hCkDJ_4AfCap2svg"
```
Per ulteriori informazioni, consulta [upload-part-copy](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/upload-part-copy.html ) nella AWS Command Line Interface.
### Elenco dei caricamenti multiparte in corso
Per elencare i caricamenti multiparte in corso in un bucket di directory, puoi usare il, o il AWS SDKs. AWS CLI
#### Usando il AWS SDKs
------
#### [ SDK for Java 2.x ]
Gli esempi seguenti mostrano come elencare i caricamenti multiparte in corso (incompleti) utilizzando l'SDK per Java 2.x.
**Example**
```
public static void listMultiPartUploads( S3Client s3, String bucketName) {
try {
ListMultipartUploadsRequest listMultipartUploadsRequest = ListMultipartUploadsRequest.builder()
.bucket(bucketName)
.build();
ListMultipartUploadsResponse response = s3.listMultipartUploads(listMultipartUploadsRequest);
List MultipartUpload uploads = response.uploads();
for (MultipartUpload upload: uploads) {
System.out.println("Upload in progress: Key = \"" + upload.key() + "\", id = " + upload.uploadId());
}
}
catch (S3Exception e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
```
------
#### [ SDK for Python ]
Gli esempi seguenti mostrano come elencare i caricamenti multiparte in corso (incompleti) utilizzando l'SDK per Python.
**Example**
```
import logging
import boto3
from botocore.exceptions import ClientError
def list_multipart_uploads(s3_client, bucket_name):
'''
List any incomplete multipart uploads in a directory bucket in e specified gion
:param s3_client: boto3 S3 client
:param bucket_name: Bucket to check for incomplete multipart uploads
:return: List of incomplete multipart uploads if there are any, None if not
'''
try:
response = s3_client.list_multipart_uploads(Bucket = bucket_name)
if 'Uploads' in response.keys():
return response['Uploads']
else:
return None
except ClientError as e:
logging.error(e)
if __name__ == '__main__':
bucket_name = 'BUCKET_NAME'
region = 'us-west-2'
s3_client = boto3.client('s3', region_name = region)
multipart_uploads = list_multipart_uploads(s3_client, bucket_name)
if multipart_uploads is not None:
print (f'There are {len(multipart_uploads)} ncomplete multipart uploads for {bucket_name}')
else:
print (f'There are no incomplete multipart uploads for {bucket_name}')
```
------
#### Usando il AWS CLI
Gli esempi seguenti mostrano come elencare i caricamenti multiparte in corso (incompleti) utilizzando AWS CLI. Per utilizzare il comando sostituiscili *user input placeholders* con le tue informazioni.
```
aws s3api list-multipart-uploads --bucket bucket-base-name--zone-id--x-s3
```
Per ulteriori informazioni, consulta [list-multipart-uploads](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/list-multipart-uploads.html ) nella AWS Command Line Interface.
### Elenco di parti di un caricamento multiparte
Gli esempi seguenti mostrano come elencare le parti di un caricamento multiparte in un bucket di directory.
#### Usando il AWS SDKs
------
#### [ SDK for Java 2.x ]
Gli esempi seguenti mostrano come elencare le parti di un caricamento multipartito in un bucket di directory utilizzando l'SDK per Java 2.x.
```
public static void listMultiPartUploadsParts( S3Client s3, String bucketName, String objKey, String uploadID) {
try {
ListPartsRequest listPartsRequest = ListPartsRequest.builder()
.bucket(bucketName)
.uploadId(uploadID)
.key(objKey)
.build();
ListPartsResponse response = s3.listParts(listPartsRequest);
ListPart parts = response.parts();
for (Part part: parts) {
System.out.println("Upload in progress: Part number = \"" + part.partNumber() + "\", etag = " + part.eTag());
}
}
catch (S3Exception e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
```
------
#### [ SDK for Python ]
Gli esempi seguenti mostrano come elencare le parti di un caricamento multipartito in un bucket di directory utilizzando SDK per Python.
```
import logging
import boto3
from botocore.exceptions import ClientError
def list_parts(s3_client, bucket_name, key_name, upload_id):
'''
Lists the parts that have been uploaded for a specific multipart upload to a directory bucket.
:param s3_client: boto3 S3 client
:param bucket_name: Bucket that multipart uploads parts have been uploaded to
:param key_name: Name of the object that has parts uploaded
:param upload_id: Multipart upload ID that the parts are associated with
:return: List of parts associated with the specified multipart upload, None if there are no parts
'''
parts_list = []
next_part_marker = ''
continuation_flag = True
try:
while continuation_flag:
if next_part_marker == '':
response = s3_client.list_parts(
Bucket = bucket_name,
Key = key_name,
UploadId = upload_id
)
else:
response = s3_client.list_parts(
Bucket = bucket_name,
Key = key_name,
UploadId = upload_id,
NextPartMarker = next_part_marker
)
if 'Parts' in response:
for part in response['Parts']:
parts_list.append(part)
if response['IsTruncated']:
next_part_marker = response['NextPartNumberMarker']
else:
continuation_flag = False
else:
continuation_flag = False
return parts_list
except ClientError as e:
logging.error(e)
return None
if __name__ == '__main__':
region = 'us-west-2'
bucket_name = 'BUCKET_NAME'
key_name = 'KEY_NAME'
upload_id = 'UPLOAD_ID'
s3_client = boto3.client('s3', region_name = region)
parts_list = list_parts(s3_client, bucket_name, key_name, upload_id)
if parts_list is not None:
print (f'{key_name} has {len(parts_list)} parts uploaded to {bucket_name}')
else:
print (f'There are no multipart uploads with that upload ID for {bucket_name} bucket')
```
------
#### Usando il AWS CLI
Gli esempi seguenti mostrano come elencare le parti di un caricamento multiparte in un bucket di directory utilizzando AWS CLI. Per utilizzare il comando sostituiscili *user input placeholders* con le tue informazioni.
```
aws s3api list-parts --bucket bucket-base-name--zone-id--x-s3 --key KEY_NAME --upload-id "AS_mgt9RaQE9GEaifATue15dAAAAAAAAAAEMAAAAAAAAADQwNzI4MDU0MjUyMBYAAAAAAAAAAA0AAAAAAAAAAAH2AfYAAAAAAAAEBSD0WBKMAQAAAABneY9yBVsK89iFkvWdQhRCcXohE8RbYtc9QvBOG8tNpA"
```
Per ulteriori informazioni, consulta [list-parts](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/list-parts.html) in AWS Command Line Interface.
# Copia di oggetti da o verso un bucket di directory
L'operazione copy crea una copia di un oggetto già archiviato in Amazon S3. Puoi copiare oggetti tra bucket di directory e bucket per uso generico. Inoltre, puoi copiare oggetti all'interno di un bucket e tra bucket dello stesso tipo, ad esempio, da un bucket di directory all'altro.
**Nota**
La copia di oggetti tra diversi Regioni AWS non è supportata quando il bucket di origine o di destinazione si trova in una AWS zona locale. I bucket di origine e di destinazione devono avere lo stesso Regione AWS padre. I bucket di origine e di destinazione possono essere di tipo diverso (zona di disponibilità o zona locale).
È possibile creare una copia di un oggetto fino a 5 GB in una singola operazione atomica. Tuttavia, per copiare un oggetto di dimensioni superiori a 5 GB, è necessario utilizzare le operazioni API di caricamento multiparte. Per ulteriori informazioni, consulta [Utilizzo dei caricamenti multiparte con i bucket di directory](s3-express-using-multipart-upload.md).
**Permissions**
Per copiare oggetti, è necessario disporre delle seguenti autorizzazioni:
+ Per copiare oggetti da un bucket di directory a un altro, è necessario disporre dell'autorizzazione `s3express:CreateSession`.
+ Per copiare gli oggetti dai bucket di directory ai bucket per uso generico, è necessario disporre dell'autorizzazione `s3express:CreateSession` e dell'autorizzazione `s3:PutObject` per scrivere la copia dell'oggetto nel bucket di destinazione.
+ Per copiare oggetti da bucket per uso generico a bucket di directory, è necessario disporre dei permessi `s3express:CreateSession` e `s3:GetObject` per leggere l'oggetto di origine che si sta copiando.
Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html) in *Amazon Simple Storage Service API Reference* (Guida di riferimento per l'API di Amazon Simple Storage Service).
**Encryption (Crittografia)**
Amazon S3 esegue automaticamente la crittografa di tutti i nuovi oggetti caricati in un bucket S3. La configurazione di crittografia predefinita di un bucket S3 è sempre abilitata ed è impostata almeno sulla crittografia lato server con chiavi gestite di Amazon S3 (SSE-S3).
Per i bucket di directory, sono supportati SSE-S3 e la crittografia lato server con chiavi () (SSE-KMS). AWS Key Management Service AWS KMS Quando il bucket di destinazione è un bucket di directory, si consiglia di utilizzare la configurazione di crittografia desiderata come crittografia predefinita per il bucket di destinazione e di non sostituire la crittografia predefinita del bucket. I nuovi oggetti vengono quindi crittografati automaticamente con le impostazioni di crittografia desiderate. Inoltre, le chiavi dei bucket S3 non sono supportate quando si copiano oggetti con crittografia SSE-KMS da bucket per uso generico a bucket di directory, da bucket di directory a bucket per uso generico o tra bucket di directory, tramite [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html). In questo caso, Amazon S3 effettua una chiamata AWS KMS ogni volta che viene effettuata una richiesta di copia per un oggetto crittografato con KMS. Per ulteriori informazioni sui comportamenti di sovrascrittura della crittografia nei bucket di directory, consulta [Specificare la crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-specifying-kms-encryption.html) con per il caricamento di nuovi oggetti. AWS KMS
Per i bucket generici, è possibile utilizzare SSE-S3 (impostazione predefinita), la crittografia lato server con () chiavi (SSE-KMS), la crittografia lato server a due livelli con chiavi AWS Key Management Service (DSSE-KMS AWS KMS) o la crittografia lato server con chiavi fornite dal cliente (SSE-C). AWS KMS
Se si effettua una richiesta di copia che specifica di utilizzare DSSE-KMS o SSE-C per un bucket di directory (sia quello di origine che quello di destinazione), la risposta restituisce un errore.
**Tag**
I bucket di directory non supportano i tag. Se si copia un oggetto con tag da un bucket per uso generico a un bucket di directory, si riceve una risposta HTTP `501 (Not Implemented)`. Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html) in *Amazon Simple Storage Service API Reference* (Guida di riferimento per l'API di Amazon Simple Storage Service).
**ETags**
ETagsI tag di entità () per S3 Express One Zone sono stringhe alfanumeriche casuali e non sono checksum. MD5 Per garantire l'integrità degli oggetti, utilizza checksum aggiuntivi.
**Checksum aggiuntivi**
S3 Express One Zone offre la possibilità di scegliere l'algoritmo di checksum utilizzato per convalidare i dati durante il caricamento o il download. È possibile selezionare uno dei seguenti algoritmi di controllo dell'integrità dei dati Secure Hash Algorithms (SHA) o Cyclic Redundancy Check (CRC):, C, SHA-1 e SHA-256. CRC32 CRC32 MD5i checksum basati non sono supportati con la classe di storage S3 Express One Zone.
Per ulteriori informazioni, consulta [Best practice per il checksum S3 aggiuntivo](s3-express-optimizing-performance.md#s3-express-optimizing-performance-checksums).
**Funzionalità supportate**
Per ulteriori informazioni sulle caratteristiche di Amazon S3 supportate da S3 Express One Zone, consulta [Differenze per i bucket di directory](s3-express-differences.md).
## Utilizzo della console S3 (copia in un bucket di directory)
**Nota**
Le restrizioni e le limitazioni quando si copia un oggetto in un bucket di directory con la console sono le seguenti:
L'azione `Copy` si applica a tutti gli oggetti all'interno delle cartelle (prefissi) specificate. Gli oggetti aggiunti a queste cartelle mentre l'azione è in corso potrebbero essere interessati.
Gli oggetti crittografati con chiavi di crittografia fornite dal cliente (SSE-C) non possono essere copiati utilizzando la console S3. Per copiare oggetti crittografati con SSE-C, usa l' AWS CLI AWS SDK o l'API REST di Amazon S3.
Gli oggetti copiati non manterranno le impostazioni di Object Lock dagli oggetti originali.
Se il bucket da cui stai copiando gli oggetti utilizza l'impostazione imposta dal proprietario del bucket per S3 Object Ownership, l'oggetto non verrà copiato nella destinazione specificata. ACLs
Se desideri copiare oggetti in un bucket che utilizza l'impostazione forzata del proprietario del bucket per S3 Object Ownership, assicurati che il bucket di origine utilizzi anche l'impostazione applicata dal proprietario del bucket o rimuovi qualsiasi oggetto concesso dall'ACL ad altri account e gruppi. AWS
Gli oggetti copiati da un bucket generico a un bucket di directory non conserveranno i tag degli oggetti o i valori Etag. ACLs I valori di checksum possono essere copiati, ma non sono equivalenti a un ETag. Il valore del checksum può cambiare rispetto a quando è stato aggiunto.
Tutti gli oggetti copiati in un bucket della directory saranno con il proprietario del bucket impostato per la proprietà degli oggetti S3.
**Per copiare un oggetto da un bucket per uso generico o da un bucket di directory a un bucket di directory**
1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Nel riquadro di navigazione di sinistra, specifica il tipo di bucket da cui copiare gli oggetti:
+ Per copiare da un bucket per uso generico, scegli la scheda **Bucket per uso generico**.
+ Per copiare da un bucket di directory, scegli la scheda **Bucket di directory**.
1. Scegli il bucket per uso generico o il bucket della directory che contiene gli oggetti da copiare.
1. Scegli la scheda **Objects** (Oggetti). Nella pagina **Oggetti**, seleziona la casella di controllo a sinistra dei nomi degli oggetti da copiare.
1. Nel menu **Actions (Operazioni)** scegliere **Copy (Copia)**.
Viene visualizzata la pagina **Copia**.
1. In **Destinazione**, scegli **Directory bucket** per il tipo di destinazione. Per specificare il percorso di destinazione, scegli **Sfoglia S3**, navigare fino alla destinazione e scegli il pulsante di opzione a sinistra della destinazione. Seleziona **Choose destination (Scegli destinazione)** nell'angolo in basso a destra.
In alternativa, immettere il percorso di destinazione.
1. In **Impostazioni di copia aggiuntive**, scegli se eseguire **Copia impostazioni dell'origine**, **Non specificare le impostazioni** o **Specifica le impostazioni**. **Copia impostazioni dell'origine** è l'opzione predefinita. Se desideri copiare solo l'oggetto senza gli attributi delle impostazioni dell'origine, scegli **Non specificare le impostazioni**. Scegli **Specifica impostazioni** per specificare le impostazioni di crittografia lato server, checksum e metadati.
1. Scegli **Copy (Copia)** nell'angolo in basso a destra. Amazon S3 copia gli oggetti nella destinazione.
## Utilizzo della console S3 (copia in un bucket per uso generico)
**Nota**
Le restrizioni e le limitazioni quando si copia un oggetto in un bucket per uso generico con la console sono le seguenti:
L'azione `Copy` si applica a tutti gli oggetti all'interno delle cartelle (prefissi) specificate. Gli oggetti aggiunti a queste cartelle mentre l'azione è in corso potrebbero essere interessati.
Gli oggetti crittografati con chiavi di crittografia fornite dal cliente (SSE-C) non possono essere copiati utilizzando la console S3. Per copiare oggetti crittografati con SSE-C, usa l' AWS CLI AWS SDK o l'API REST di Amazon S3.
Gli oggetti copiati non manterranno le impostazioni di Object Lock dagli oggetti originali.
Se il bucket da cui stai copiando gli oggetti utilizza l'impostazione imposta dal proprietario del bucket per S3 Object Ownership, l'oggetto non verrà copiato nella destinazione specificata. ACLs
Se desideri copiare oggetti in un bucket che utilizza l'impostazione forzata del proprietario del bucket per S3 Object Ownership, assicurati che il bucket di origine utilizzi anche l'impostazione applicata dal proprietario del bucket o rimuovi qualsiasi oggetto concesso dall'ACL ad altri account e gruppi. AWS
**Per copiare un oggetto da un bucket di directory in un bucket per uso generico**
1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Nel pannello di navigazione a sinistra, scegli **Buckets** (Bucket).
1. Scegli la scheda ** Bucket di directory**.
1. Scegli il bucket della directory che contiene gli oggetti da copiare.
1. Scegli la scheda **Objects** (Oggetti). Nella pagina **Oggetti**, seleziona la casella di controllo a sinistra dei nomi degli oggetti da copiare.
1. Nel menu **Actions (Operazioni)** scegliere **Copy (Copia)**.
1. Alla voce **Destinazione**, scegli il **Bucket per uso generico** per il tipo di destinazione. Per specificare il percorso di destinazione, scegli **Sfoglia S3**, naviga fino alla destinazione e scegli il pulsante di opzione a sinistra della destinazione. Seleziona **Choose destination (Scegli destinazione)** nell'angolo in basso a destra.
In alternativa, immettere il percorso di destinazione.
1. In **Impostazioni di copia aggiuntive**, scegli se eseguire **Copia impostazioni dell'origine**, **Non specificare le impostazioni** o **Specifica le impostazioni**. **Copia impostazioni dell'origine** è l'opzione predefinita. Se desideri copiare solo l'oggetto senza gli attributi delle impostazioni dell'origine, scegli **Non specificare le impostazioni**. Scegli **Specificare le impostazioni** per specificare le impostazioni per la classe di archiviazione ACLs, i tag degli oggetti, i metadati, la crittografia lato server e i checksum aggiuntivi.
1. Scegli **Copy (Copia)** nell'angolo in basso a destra. Amazon S3 copia gli oggetti nella destinazione.
## Usando il AWS SDKs
------
#### [ SDK for Java 2.x ]
**Example**
```
public static void copyBucketObject (S3Client s3, String sourceBucket, String objectKey, String targetBucket) {
CopyObjectRequest copyReq = CopyObjectRequest.builder()
.sourceBucket(sourceBucket)
.sourceKey(objectKey)
.destinationBucket(targetBucket)
.destinationKey(objectKey)
.build();
String temp = "";
try {
CopyObjectResponse copyRes = s3.copyObject(copyReq);
System.out.println("Successfully copied " + objectKey +" from bucket " + sourceBucket +" into bucket "+targetBucket);
}
catch (S3Exception e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
```
------
## Usando il AWS CLI
Il comando di `copy-object` esempio seguente mostra come è possibile utilizzare AWS CLI per copiare un oggetto da un bucket a un altro bucket. È possibile copiare gli oggetti tra i tipi di bucket. Per eseguire questo comando, sostituisci i segnaposto inseriti dall'utente con le tue informazioni.
```
aws s3api copy-object --copy-source SOURCE_BUCKET/SOURCE_KEY_NAME --key TARGET_KEY_NAME --bucket TARGET_BUCKET_NAME
```
Per ulteriori informazioni, consulta [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/copy-object.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/copy-object.html) nella *documentazione di riferimento dei comandi della AWS CLI *.
# Eliminazione di oggetti da un bucket di directory
Puoi eliminare oggetti da un bucket di directory Amazon S3 utilizzando la console Amazon S3, AWS Command Line Interface () o.AWS CLI AWS SDKs Per ulteriori informazioni, consultare [Operazioni con i bucket di directory](directory-buckets-overview.md) e [S3 Express One Zone](directory-bucket-high-performance.md#s3-express-one-zone).
**avvertimento**
L'eliminazione di un oggetto non può essere annullata.
Questa azione elimina tutti gli oggetti specificati. Quando si eliminano le cartelle, attendere che l'azione di eliminazione finisca prima di aggiungere nuovi oggetti alla cartella. In caso contrario, potrebbero essere eliminati anche nuovi oggetti.
**Nota**
Quando si eliminano programmaticamente più oggetti da un bucket della directory, si noti quanto segue:
Le chiavi degli oggetti nelle richieste `DeleteObjects` devono contenere almeno un carattere diverso dallo spazio. Le stringhe con tutti i caratteri di spazio bianco non sono supportate.
Le chiavi degli oggetti nelle richieste di `DeleteObjects` non possono contenere caratteri di controllo Unicode, ad eccezione di newline (`\n`), tab (`\t`) e carriage return (`\r`).
## Utilizzo della console S3
**Per eliminare oggetti**
1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Nel riquadro di navigazione a sinistra, scegli **Bucket di directory**.
1. Scegli il bucket della directory che contiene gli oggetti da eliminare.
1. Scegli la scheda **Objects** (Oggetti). Nell'elenco **Oggetti**, seleziona la casella di controllo a sinistra dell'oggetto o degli oggetti che si desidera eliminare.
1. Scegli **Elimina**.
1. Nella pagina **Elimina oggetti** inserisci **permanently delete** nella casella di testo.
1. Scegliere **Delete objects (Elimina oggetti)**.
## Utilizzando il AWS SDKs
------
#### [ SDK for Java 2.x ]
**Example**
L'esempio seguente elimina gli oggetti di un bucket di directory usando AWS SDK for Java 2.x.
```
static void deleteObject(S3Client s3Client, String bucketName, String objectKey) {
try {
DeleteObjectRequest del = DeleteObjectRequest.builder()
.bucket(bucketName)
.key(objectKey)
.build();
s3Client.deleteObject(del);
System.out.println("Object " + objectKey + " has been deleted");
} catch (S3Exception e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
```
------
#### [ SDK for Python ]
**Example**
L'esempio seguente elimina gli oggetti di un bucket di directory usando AWS SDK per Python (Boto3).
```
import logging
import boto3
from botocore.exceptions import ClientError
def delete_objects(s3_client, bucket_name, objects):
'''
Delete a list of objects in a directory bucket
:param s3_client: boto3 S3 client
:param bucket_name: Bucket that contains objects to be deleted; for example, 'doc-example-bucket--usw2-az1--x-s3'
:param objects: List of dictionaries that specify the key names to delete
:return: Response output, else False
'''
try:
response = s3_client.delete_objects(
Bucket = bucket_name,
Delete = {
'Objects': objects
}
)
return response
except ClientError as e:
logging.error(e)
return False
if __name__ == '__main__':
region = 'us-west-2'
bucket_name = 'BUCKET_NAME'
objects = [
{
'Key': '0.txt'
},
{
'Key': '1.txt'
},
{
'Key': '2.txt'
},
{
'Key': '3.txt'
},
{
'Key': '4.txt'
}
]
s3_client = boto3.client('s3', region_name = region)
results = delete_objects(s3_client, bucket_name, objects)
if results is not None:
if 'Deleted' in results:
print (f'Deleted {len(results["Deleted"])} objects from {bucket_name}')
if 'Errors' in results:
print (f'Failed to delete {len(results["Errors"])} objects from {bucket_name}')
```
------
## Usando il AWS CLI
Il seguente esempio di comando `delete-object` mostra come si può usare il comando AWS CLI per eliminare un oggetto da un bucket della directory. Per eseguire questo comando, sostituisci `user input placeholders` con le informazioni appropriate.
```
aws s3api delete-object --bucket bucket-base-name--zone-id--x-s3 --key KEY_NAME
```
Per ulteriori informazioni, consulta [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/delete-object.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/delete-object.html) nella *documentazione di riferimento dei comandi della AWS CLI *.
Il seguente esempio di comando `delete-objects` mostra come utilizzare la AWS CLI per eliminare un oggetto da un bucket di directory. Per eseguire questo comando, sostituisci `user input placeholders` con le informazioni appropriate.
Il file `delete.json` è il seguente:
```
{
"Objects": [
{
"Key": "0.txt"
},
{
"Key": "1.txt"
},
{
"Key": "2.txt"
},
{
"Key": "3.txt"
}
]
}
```
Il comando di esempio `delete-objects` è il seguente:
```
aws s3api delete-objects --bucket bucket-base-name--zone-id--x-s3 --delete file://delete.json
```
Per ulteriori informazioni, consulta [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/delete-objects.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/delete-objects.html) nella *documentazione di riferimento dei comandi della AWS CLI *.
# Download di un oggetto da un bucket di directory
I seguenti esempi di codice mostrano come leggere (scaricare) i dati da un oggetto in un bucket della directory Amazon S3 utilizzando l'operazione API `GetObject`.
## Usando il AWS SDKs
------
#### [ SDK for Java 2.x ]
**Example**
Il seguente esempio di codice mostra come leggere i dati da un oggetto in un bucket di directory, usando AWS SDK for Java 2.x.
```
public static void getObject(S3Client s3Client, String bucketName, String objectKey) {
try {
GetObjectRequest objectRequest = GetObjectRequest
.builder()
.key(objectKey)
.bucket(bucketName)
.build();
ResponseBytes GetObjectResponse objectBytes = s3Client.getObjectAsBytes(objectRequest);
byte[] data = objectBytes.asByteArray();
//Print object contents to console
String s = new String(data, StandardCharsets.UTF_8);
System.out.println(s);
}
catch (S3Exception e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
```
------
#### [ SDK for Python ]
**Example**
Il seguente esempio di codice mostra come leggere i dati da un oggetto in un bucket di directory, usando AWS SDK per Python (Boto3).
```
import boto3
from botocore.exceptions import ClientError
from botocore.response import StreamingBody
def get_object(s3_client: boto3.client, bucket_name: str, key_name: str) -> StreamingBody:
"""
Gets the object.
:param s3_client:
:param bucket_name: The bucket that contains the object.
:param key_name: The key of the object to be downloaded.
:return: The object data in bytes.
"""
try:
response = s3_client.get_object(Bucket=bucket_name, Key=key_name)
body = response['Body'].read()
print(f"Got object '{key_name}' from bucket '{bucket_name}'.")
except ClientError:
print(f"Couldn't get object '{key_name}' from bucket '{bucket_name}'.")
raise
else:
return body
def main():
s3_client = boto3.client('s3')
resp = get_object(s3_client, 'doc-example-bucket--use1-az4--x-s3', 'sample.txt')
print(resp)
if __name__ == "__main__":
main()
```
------
## Usando il AWS CLI
L'esempio `get-object` seguente mostra come utilizzare la AWS CLI per scaricare un oggetto da Amazon S3. Questo comando ottiene l'oggetto `KEY_NAME` dal bucket della directory `bucket-base-name--zone-id--x-s3`. L'oggetto verrà scaricato in un file denominato `LOCAL_FILE_NAME`. Per eseguire questo comando, sostituisci `user input placeholders` con le informazioni appropriate.
```
aws s3api get-object --bucket bucket-base-name--zone-id--x-s3 --key KEY_NAME LOCAL_FILE_NAME
```
Per ulteriori informazioni, consulta [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/get-object.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/get-object.html) nella *documentazione di riferimento dei comandi della AWS CLI *.
# Generazione di un bucket URLs di directory preimpostato per la condivisione di oggetti
I seguenti esempi di codice mostrano come generare oggetti predefiniti URLs per la condivisione da un bucket di directory Amazon S3.
## Usando il AWS CLI
Il seguente esempio di comando mostra come utilizzare la AWS CLI per generare un URL prefirmato per un oggetto su Amazon S3. Questo comando genera un URL prefirmato per un oggetto `KEY_NAME` dal bucket di directory `bucket-base-name--zone-id--x-s3`. Per eseguire questo comando, sostituisci `user input placeholders` con le informazioni appropriate.
```
aws s3 presign s3://bucket-base-name--zone-id--x-s3/KEY_NAME --expires-in 7200
```
Per ulteriori informazioni, consulta [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3/presign.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3/presign.html) nella *documentazione di riferimento dei comandi della AWS CLI *.
# Recupero dei metadati degli oggetti dai bucket della directory
I seguenti esempi di AWS SDK e AWS CLI mostrano come utilizzare l'operazione `GetObjectAttributes` and API per recuperare `HeadObject` i metadati da un oggetto in un bucket di directory Amazon S3 senza restituire l'oggetto stesso.
## Usando il AWS SDKs
------
#### [ SDK for Java 2.x ]
**Example**
```
public static void headObject(S3Client s3Client, String bucketName, String objectKey) {
try {
HeadObjectRequest headObjectRequest = HeadObjectRequest
.builder()
.bucket(bucketName)
.key(objectKey)
.build();
HeadObjectResponse response = s3Client.headObject(headObjectRequest);
System.out.format("Amazon S3 object: \"%s\" found in bucket: \"%s\" with ETag: \"%s\"", objectKey, bucketName, response.eTag());
}
catch (S3Exception e) {
System.err.println(e.awsErrorDetails().errorMessage());
```
------
## Usando il AWS CLI
Il comando di `head-object` esempio seguente mostra come è possibile utilizzare AWS CLI per recuperare i metadati da un oggetto. Per eseguire questo comando, sostituisci `user input placeholders` con le informazioni appropriate.
```
aws s3api head-object --bucket bucket-base-name--zone-id--x-s3 --key KEY_NAME
```
Per ulteriori informazioni, consulta [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/head-object.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/head-object.html) nella *documentazione di riferimento dei comandi della AWS CLI *.
Il comando di `get-object-attributes` esempio seguente mostra come utilizzare il AWS CLI per recuperare i metadati da un oggetto. Per eseguire questo comando, sostituisci `user input placeholders` con le informazioni appropriate.
```
aws s3api get-object-attributes --bucket bucket-base-name--zone-id--x-s3 --key KEY_NAME --object-attributes "StorageClass" "ETag" "ObjectSize"
```
Per ulteriori informazioni, consulta [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/get-object-attributes.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/get-object-attributes.html) nella *documentazione di riferimento dei comandi della AWS CLI *.
# Elenco degli oggetti di un bucket di directory
I seguenti esempi di codice mostrano come elencare gli oggetti di un bucket di directory Amazon S3 utilizzando l’operazione API `ListObjectsV2`.
## Utilizzando il AWS CLI
Il seguente esempio di comando `list-objects-v2` mostra come utilizzare la AWS CLI per elencare gli oggetti da Amazon S3. Questo comando elenca gli oggetti del bucket di directory `bucket-base-name--zone-id--x-s3`. Per eseguire questo comando, sostituisci `user input placeholders` con le informazioni appropriate.
```
aws s3api list-objects-v2 --bucket bucket-base-name--zone-id--x-s3
```
Per ulteriori informazioni, consulta [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/list-objects-v2.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/list-objects-v2.html) nella *documentazione di riferimento dei comandi della AWS CLI *.