La versione 5 (V5) di AWS Strumenti per PowerShell è stata rilasciata\! Per informazioni sulle modifiche sostanziali e sulla migrazione delle applicazioni, consulta l'argomento sulla [ migrazione. ](https://docs.aws.amazon.com/powershell/v5/userguide/migrating-v5.html) [![Orange button with text "Click here for details".](https://docs.aws.amazon.com/it_it/powershell/v5/userguide/images/BannerButton_less-round.png)](https://docs.aws.amazon.com/powershell/v5/userguide/migrating-v5.html) 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à. # Usa Amazon S3 come unità PowerShell *Si applica a: `AWS.Tools.S3` 5.0.288 e versioni successive. Il provider di unità S3 e i relativi cmdlet sono inclusi nel `AWS.Tools.S3` modulo, che funziona su Windows PowerShell 5.1 e PowerShell 7\+ (Windows, Linux, macOS). * L' PowerShell unità S3 ti consente di montare lo storage Amazon S3 come unità e di utilizzarlo nello stesso modo in cui lavori con un disco locale. Dopo aver montato un'unità, il provider presenta bucket e prefissi come cartelle e oggetti come file. I comandi di navigazione più comuni funzionano direttamente con S3, tra cui`Set-Location`,`Get-ChildItem`, `Get-Content` e. `Set-Content` `Remove-Item` Questo argomento riguarda l'installazione, il montaggio, la navigazione, il trasferimento e lo smontaggio dei contenuti, oltre alle credenziali, alla regione e al comportamento di sicurezza dell'unità S3. **I separatori di percorso differiscono in base alla piattaforma** Gli esempi in questo argomento utilizzano `/` come separatore di percorso, che l'unità accetta su tutte le piattaforme. In Windows l'unità accetta anche`\`, quindi `S3:\amzn-s3-demo-bucket\reports` e lì `S3:/amzn-s3-demo-bucket/reports` sono equivalenti. Solo su Linux e macOS `/` è un separatore, quindi usa quel modulo negli script eseguiti su più di una piattaforma. I percorsi restituiti dall'unità, ad esempio`PSPath`, utilizzano il separatore nativo del sistema operativo: `\` su Windows, su Linux e macOS`/`. ## Prerequisiti + Il `AWS.Tools.S3` modulo, 5.0.288 o successivo. Installalo direttamente dalla PowerShell Galleria (anche questo include la sua `AWS.Tools.Common` dipendenza): ``` Install-Module -Name AWS.Tools.S3 -MinimumVersion 5.0.288 ``` Oppure, se gestisci gli strumenti modulari con il `AWS.Tools.Installer` modulo, installalo prima e poi usa: `Install-AWSToolsModule` ``` Install-Module -Name AWS.Tools.Installer # provides Install-AWSToolsModule Install-AWSToolsModule AWS.Tools.S3 ``` Il provider dell'unità e i relativi cmdlet vengono forniti all'interno. `AWS.Tools.S3` Non è richiesta alcuna installazione aggiuntiva. + AWS credenziali configurate allo stesso modo di qualsiasi cmdlet S3 (un profilo denominato, variabili di ambiente, un ruolo IAM o SSO). Per ulteriori informazioni, consulta [Inizia con AWS Strumenti per PowerShell](pstools-getting-set-up.md). L'importazione del modulo registra un provider denominato. PowerShell `AWS.S3` Puoi confermare che è disponibile: ``` Get-PSProvider AWS.S3 ``` ## Montare un'unità `Mount-S3PSDrive`Usare per creare un'unità. Il `-Name` parametro diventa il nome dell'unità in ogni percorso (ad esempio, `-Name S3` fornisce percorsi simili`S3:/amzn-s3-demo-bucket/reports/index.txt`). ``` # Mount an S3: drive using a named profile and Region Mount-S3PSDrive -Name S3 -ProfileName my-profile -Region us-east-1 # List buckets Get-ChildItem S3:/ ``` Output di esempio: ``` Type LastModified Size Name ---- ------------ ---- ---- Bucket 2026-06-02 09:14:03 amzn-s3-demo-app-logs Bucket 2026-01-08 16:47:51 amzn-s3-demo-reports ``` Se hai già impostato i valori predefiniti della sessione con `Set-AWSCredential` e`Set-DefaultAWSRegion`, puoi eseguire il montaggio senza altri parametri: ``` Set-AWSCredential -ProfileName my-profile Set-DefaultAWSRegion us-west-2 Mount-S3PSDrive -Name S3 ``` `Mount-S3PSDrive`è un involucro sottile rispetto a quello integrato. PowerShell `New-PSDrive` Se preferisci, puoi creare direttamente l'unità e passare le stesse credenziali e i parametri della regione: ``` New-PSDrive -Name S3 -PSProvider AWS.S3 -Root '' -Scope Global -ProfileName my-profile -Region us-east-1 ``` **Usando direttamente New-PSDrive** Passa `-Scope Global` quando lo usi `New-PSDrive` direttamente. In caso contrario, l'unità viene creata nell'ambito corrente e scompare quando tale ambito viene chiuso (ad esempio, quando ritorna lo script o la funzione che l'ha creata). `Mount-S3PSDrive`set `-Scope Global` per te. Per impostazione predefinita non `Mount-S3PSDrive` produce alcun output. Aggiungi `-PassThru` se vuoi riavere l'`PSDriveInfo`oggetto. **Nome del parametro di credenziale** Il parametro delle credenziali è denominato`-AWSCredential`, non. `-Credential` `New-PSDrive`si definisce già `-Credential` come a`PSCredential`, che è un tipo diverso, quindi l'unità S3 utilizza un nome distinto per evitare una collisione. ## Come vengono risolte le credenziali e la regione Un'unità S3 autentica e seleziona una regione esattamente come fanno i cmdlet S3: prima i parametri espliciti, poi i valori predefiniti di sessione impostati da e, quindi il profilo, l'ambiente `Set-AWSCredential` e le fonti di metadati delle istanze delle `Set-DefaultAWSRegion` catene predefinite dell'SDK. Per [Utilizzo delle AWS credenziali](specifying-your-aws-credentials.md) [Specificare la AWS regione per AWS Strumenti per PowerShell](pstools-installing-specifying-region.md) l'ordine di risoluzione completo, vedere e. Se nulla rifornisce una regione, l'unità ricade su`us-east-1`. La regione che utilizzi è solo la * regione di * partenza: una singola unità può raggiungere i bucket tra le regioni (vedi[Accedi ai bucket tra le regioni da un'unica unità](#pstools-s3-drive-regions)). Un profilo errato o un bucket o prefisso mancante non funziona. `Mount-S3PSDrive` Alcuni errori di autorizzazione potrebbero non essere visualizzati finché non si accede a un oggetto. ## Naviga in Amazon S3 come un'unità locale Dopo aver montato l'unità, naviga con i comandi più comuni dell' PowerShell unità. S3 non ha cartelle reali, ma il provider presenta i prefissi come cartelle in modo da poterle navigare nello stesso modo. ``` # Change into a bucket, then a prefix Set-Location S3:/amzn-s3-demo-reports/2026 # List the current location Get-ChildItem ``` Output di esempio: ``` Type LastModified Size Name ---- ------------ ---- ---- Folder q1 Folder q2 Object 2026-03-31 18:02:11 48210 summary.txt ``` ``` # List a path without changing location Get-ChildItem S3:/amzn-s3-demo-bucket/reports/2026 ``` Il completamento tramite tabulazione funziona per bucket, prefissi e oggetti, quindi puoi completare un percorso senza inserire nomi completi. `Get-ChildItem`restituisce ogni elemento come oggetto che espone`Name`,`Type`, `Size` e proprietà. `LastModified` Queste proprietà consentono agli elenchi di reindirizzarsi direttamente a comandi come `Where-Object` e`Sort-Object`. `Type`è uno dei`Bucket`,`Folder`, o`Object`. Le cartelle e i secchi non hanno dimensioni. ``` # List the 10 largest objects with the prefix "2026" Get-ChildItem S3:/amzn-s3-demo-app-logs/2026 -Recurse | Where-Object Type -eq 'Object' | Sort-Object Size -Descending | Select-Object -First 10 Name, Size, LastModified ``` Sull'unità funzionano anche altri comandi di navigazione: ``` # Retrieve the single item at an exact path (no children) Get-Item S3:/amzn-s3-demo-bucket/reports/index.txt # Test whether a path exists and whether it is a folder or an object Test-Path S3:/amzn-s3-demo-bucket/reports # -> True Test-Path S3:/amzn-s3-demo-bucket/reports -PathType Container # -> True (a prefix) Test-Path S3:/amzn-s3-demo-bucket/reports/index.txt -PathType Leaf # -> True (an object) ``` **Gli alias dei comandi differiscono in base al sistema operativo** Questo è PowerShell il comportamento, non l'unità. In Windows, gli Unix-style alias `ls` e `rm` la `cat` mappatura ai PowerShell cmdlet funzionano. `ls S3:/amzn-s3-demo-bucket` Su Linux e macOS, PowerShell lascia questi nomi associati agli strumenti nativi (`/bin/ls`,,`/bin/cat`)`/bin/rm`, che non riconoscono un percorso S3. Di conseguenza, `ls S3:/amzn-s3-demo-bucket` esegue il sistema `ls` e fallisce. Per gli script eseguiti su tutte le piattaforme, utilizza i nomi completi dei cmdlet:`Get-ChildItem`, `Remove-Item` e. `Get-Content` (`cd`e `dir` hanno alias su tutte le piattaforme, quindi funzionano ovunque). Con`-Recurse`, la chiave di un elemento `Name` è * relativa al prefisso * (quindi può contenere`/`) e lo stesso nome della foglia può apparire con prefissi diversi. Quando hai bisogno di identificare un elemento elencato in modo inequivocabile (ad esempio, per indirizzarlo in avanti), usa il suo invece di. `PSPath` `Name` **Reindirizzare gli oggetti elencati con - in Windows 5.1 AsByteStream PowerShell** Il piping `Get-ChildItem` into `Get-Content -AsByteStream` può fallire in Windows PowerShell 5.1. Il motore potrebbe associarsi `-AsByteStream` prima di sapere che l'input reindirizzato è un percorso S3 e il FileSystem provider in 5.1 non ha tale parametro (vedi). [La lettura dei byte dei file locali varia a seconda dell'edizione](#pstools-s3-drive-local-bytes) Leggi `PSPath` invece ogni elemento in base al suo esplicito, che funziona su entrambe le edizioni: ``` # Read each listed object by explicit PSPath Get-ChildItem S3:/amzn-s3-demo-bucket/prefix | ForEach-Object { Get-Content -LiteralPath $_.PSPath -AsByteStream -Raw } ``` Su PowerShell 7\+ il direct pipe funziona, ma il modulo per elemento è un'impostazione predefinita sicura per gli script eseguiti su entrambe le edizioni. **Le inserzioni possono essere interrotte senza problemi** Le inserzioni vengono visualizzate man mano che ogni pagina di risultati arriva da S3 e può essere interrotta premendo Ctrl\+C. Un prefisso con un numero elevato di oggetti inizia a produrre immediatamente l'output invece di attendere la fine dell'elenco completo. **Caratteri jolly nelle chiavi** Le chiavi S3 possono contenere legalmente caratteri PowerShell jolly (`[`,,`]`,`*`). `?` Per indirizzare letteralmente tale chiave, utilizzate `-LiteralPath` (supportata da`Get-Item`,`Get-Content`, e`Remove-Item`)`Set-Content`, nello stesso modo in cui utilizzate il provider del file system: ``` Get-Content -LiteralPath 'S3:/amzn-s3-demo-bucket/data[2026].csv' -Raw ``` **Test-Path e oggetti che non puoi leggere** `Test-Path`restituisce `$true` un percorso che non puoi leggere. Conferma che il percorso è stato risolto; non conferma che tu abbia il permesso di leggerlo o scriverlo. ## Legge oggetti da S3 `Get-Content`scarica un oggetto. Per impostazione predefinita, restituisce il testo riga per riga. Aggiungi `-Raw` per restituire l'intero oggetto come una singola stringa. Entrambi `Get-Content` e `Set-Content` supporto `-Encoding` per testo e `-AsByteStream` contenuto binario. ``` # Read an object line by line Get-Content S3:/amzn-s3-demo-reports/2026/summary.txt # Read the whole object as one string Get-Content S3:/amzn-s3-demo-reports/2026/summary.txt -Raw ``` Per oggetti non di testo, usa `-AsByteStream` per ottenere i byte grezzi. Su un percorso S3 questo funziona sia su PowerShell 7\+ che su Windows PowerShell 5.1 perché il provider S3 fornisce il parametro. Solo * i file * locali differiscono in base all'edizione (vedi). [La lettura dei byte dei file locali varia a seconda dell'edizione](#pstools-s3-drive-local-bytes) Per controllare la decodifica del testo, aggiungete `-Encoding` con uno qualsiasi dei nomi di PowerShell codifica standard (`UTF8`,`UTF8BOM`, `Unicode``ASCII`, e così via). L'impostazione predefinita è UTF-8 senza distinta base, su entrambi e. `Get-Content` `Set-Content` ``` # Read raw bytes Get-Content S3:/amzn-s3-demo-bucket/images/logo.png -AsByteStream -Raw # Decode as a specific text encoding Get-Content S3:/amzn-s3-demo-bucket/data/report.csv -Encoding UTF8 ``` `Get-Content`accetta anche `-PartSize` di impostare la dimensione della parte di * download in più * parti, in byte, tra il minimo S3 di 5 MiB e il massimo di 5 GiB. Si attiva`Set-Content`, `-PartSize` il che imposta la dimensione della parte caricata (vedi). [Carica oggetti molto grandi](#pstools-s3-drive-large-objects) **Lettura di byte grezzi in una variabile** Se carichi i byte di un oggetto in una variabile (per eseguirne l'hashing, misurarli o passarli a un'altra API), appiattisci prima il risultato. `-AsByteStream` In caso contrario, `.Length` il confronto dei byte produce risultati errati: ``` $bytes = [byte[]]((Get-Content S3:/amzn-s3-demo-bucket/images/logo.png -AsByteStream -Raw) | ForEach-Object { $_ }) ``` Il reindirizzamento a un file o a un altro comando (ad esempio`Set-Content -AsByteStream`, as in[Copia oggetti tra S3 e il disco locale](#pstools-s3-drive-copy)) non richiede alcun appiattimento. ## Scrivere oggetti in S3 `Set-Content`carica (e sovrascrive) un oggetto. ``` # Write text Set-Content S3:/amzn-s3-demo-reports/2026/notes.txt -Value 'Draft complete' # Write several lines Set-Content S3:/amzn-s3-demo-bucket/notes/list.txt -Value @('alpha', 'beta', 'gamma') # Write raw bytes Set-Content S3:/amzn-s3-demo-bucket/images/logo.png -AsByteStream -Value $bytes ``` I caricamenti hanno le seguenti opzioni: | Parametro | Scopo | | --- | --- | | `-Encoding` | Codifica del testo per i byte on-the-wire (impostazione predefinita UTF-8, nessuna distinta base). | | `-NoNewline` | Ometti la nuova riga finale dopo ogni valore di testo. | | `-StorageClass` | Classe di archiviazione per questo oggetto (ad esempio`STANDARD_IA`,). `GLACIER` | | `-PartSize` | Dimensione in più parti per questo caricamento, in byte (tra il minimo S3 di 5 MiB e il massimo di 5 GiB). Consulta [Carica oggetti molto grandi](#pstools-s3-drive-large-objects). | Puoi annullare un caricamento in qualsiasi momento con Ctrl\+C. Non viene eseguito alcun commit fino al termine del caricamento, quindi l'annullamento non lascia un oggetto scritto a metà al posto di quello precedente. **I caricamenti di testo utilizzano le terminazioni di riga LF** I caricamenti di testo utilizzano le terminazioni di riga LF, quindi un oggetto scritto su Windows, Linux o macOS è identico ai byte. Quando hai bisogno di un controllo preciso sui byte, usa. `-AsByteStream` ### Carica oggetti molto grandi Ogni caricamento tramite l'unità è un caricamento in più parti e S3 limita un caricamento in più parti a 10.000 parti. Con la dimensione predefinita delle parti di 5 MiB, un limite massimo per un singolo oggetto è di circa 48 GiB, e un caricamento oltre il limite massimo si esaurisce e fallisce. Per caricare qualcosa di più grande, aumenta `-PartSize` in modo che sia almeno: `object size / 10,000` ``` # Upload a ~200 GiB object with 64 MiB parts (200 GiB / 10,000 = 21 MiB, so 64 MiB is plenty) # PowerShell 7+ Get-Content ./huge.bin -AsByteStream -ReadCount 8MB | Set-Content S3:/amzn-s3-demo-bucket/archive/huge.bin -AsByteStream -PartSize 64MB # Windows PowerShell 5.1 (local read uses -Encoding Byte; the S3 write keeps -AsByteStream -PartSize) Get-Content ./huge.bin -Encoding Byte -ReadCount 8MB | Set-Content S3:/amzn-s3-demo-bucket/archive/huge.bin -AsByteStream -PartSize 64MB ``` `-PartSize`e `-StorageClass` sono parametri di destinazione S3. Usali con un percorso di destinazione S3 esplicito (come nell'esempio precedente), non con un oggetto di destinazione associato alla pipeline. `-PartSize`accetta un valore compreso tra il minimo S3 di 5 MiB e il massimo di 5 GiB. Con un massimo di 5 GiB, 10.000 parti coprono l'oggetto più grande supportato da S3 (5 TiB). **Scelta della dimensione di una parte** Un componente di dimensioni maggiori significa anche un minor numero di viaggi di andata e ritorno per un caricamento di grandi dimensioni, ma ogni componente in volo viene tenuto in memoria, quindi le parti molto grandi utilizzano più memoria. Da 5 MiB a poche centinaia di MiB è un intervallo ragionevole. Aumenta solo quando le dimensioni dell'oggetto lo richiedono. ## Copia oggetti tra S3 e il disco locale La copia * all'interno di * S3 con non `Copy-Item` è supportata (vedi). [Operazioni supportate e non supportate](#pstools-s3-drive-supported) Per spostare i dati tra il disco locale e S3, reindirizza il contenuto tramite e. `Get-Content` `Set-Content` Per i dati binari, leggi e scrivi esattamente i byte. Un ** percorso ** S3 viene utilizzato `-AsByteStream` in entrambe le PowerShell edizioni; solo il * lato * locale è diverso, come descritto in. [La lettura dei byte dei file locali varia a seconda dell'edizione](#pstools-s3-drive-local-bytes) ``` # Upload a local file (PowerShell 7+; on Windows PowerShell 5.1 the local read uses -Encoding Byte) Get-Content ./report.csv -AsByteStream -ReadCount 8MB | Set-Content S3:/amzn-s3-demo-bucket/data/report.csv -AsByteStream # Download to a local file (on Windows PowerShell 5.1 the local write uses -Encoding Byte) Get-Content S3:/amzn-s3-demo-bucket/data/report.csv -AsByteStream | Set-Content ./report.csv -AsByteStream ``` **Usa la modalità byte su entrambe le estremità per i dati binari** Leggi e scrivi byte su ** entrambe le ** estremità durante la copia di dati binari. In modalità testo, il contenuto viene decodificato e ricodificato. Una nuova riga viene normalizzata o aggiunta per ogni riga, il che danneggia i dati non testuali. Byte-mode in lettura e scrittura i byte vengono copiati esattamente. Per i file di testo, `Get-Content | Set-Content` funziona in modo semplice, con un'eccezione: text-mode `Set-Content` aggiunge una nuova riga finale (LF) e normalizza le terminazioni di riga, quindi la copia non è identica byte per byte all'origine. Se hai bisogno di una copia esatta, usala su entrambe le estremità. `-AsByteStream` ### La lettura dei byte dei file locali varia a seconda dell'edizione Il targeting di un file locale utilizza PowerShell il FileSystem provider integrato e tale provider non ne ha `-AsByteStream` in Windows PowerShell 5.1 (è arrivato nella versione PowerShell 6). Usa invece `-Encoding Byte` lì. Questa è una limitazione 5.1, non controllata dall'unità S3; un percorso S3 riguarda entrambe le `-AsByteStream` edizioni. | Edizione | Leggi i byte dei file locali | Scrivi byte di file locali | | --- | --- | --- | | **PowerShell 7\+ ** | `Get-Content $f -AsByteStream -ReadCount 8MB` | `Set-Content $f -AsByteStream` | | **Windows 5.1 PowerShell ** | `Get-Content $f -Encoding Byte -ReadCount 8MB` | `Set-Content $f -Encoding Byte` | Per le S3-to-S3 copie sul lato server, utilizzare il [ Copy-S3Object ](https://docs.aws.amazon.com/powershell/v5/reference/items/Copy-S3Object.html) cmdlet. ## Eliminare oggetti e prefissi `Remove-Item`elimina un singolo oggetto. L'eliminazione di un prefisso (una cartella con contenuti) richiede la rimozione in `-Recurse` batch di tutto ciò che contiene. ``` # Delete a single object Remove-Item S3:/amzn-s3-demo-bucket/notes/todo.txt # Delete a prefix and everything under it Remove-Item S3:/amzn-s3-demo-bucket/old-logs -Recurse ``` Il `Remove-Item` tipo di richiesta dipende dal tipo di destinazione scelto: + Un singolo oggetto, senza`-Recurse`: nessun prompt. L'oggetto viene eliminato. + Un prefisso, con`-Recurse`: nessun prompt. Tutto ciò che si trova sotto il prefisso viene eliminato. + Un prefisso non vuoto, senza`-Recurse`: richieste di conferma PowerShell . Questo è il comportamento container-has-children del provider del file system. Se confermi, l'eliminazione viene ripetuta; se rifiuti, non viene eliminato nulla. In un host non interattivo, il prompt si blocca. Passa `-Recurse` per procedere senza chiedere conferma. Usa gli PowerShell switch nativi per visualizzare in anteprima o bloccare un'eliminazione: ``` # Preview without deleting Remove-Item S3:/amzn-s3-demo-bucket/old-logs -Recurse -WhatIf # Ask for confirmation Remove-Item S3:/amzn-s3-demo-bucket/notes/todo.txt -Confirm ``` **Versioning-enabled i bucket mantengono le versioni non correnti** Su un bucket con Amazon S3 Versioning abilitato, `Remove-Item` esegue un'eliminazione standard. Aggiunge un indicatore di eliminazione e nasconde la versione corrente, ma non rimuove le versioni non correnti, che vengono mantenute e continuano a comportare costi di archiviazione. Per rimuovere le versioni in modo permanente, utilizza i cmdlet S3 (ad esempio, [ Remove-S3Object ](https://docs.aws.amazon.com/powershell/v5/reference/items/Remove-S3Object.html) con un ID di versione) o una regola del ciclo di vita di Amazon S3. **Remove-Item -Recurse si elimina senza chiedere conferma** `Remove-Item -Recurse`elimina tutti gli oggetti sotto il prefisso senza alcun prompt, come. `rm -r` In un bucket senza controllo delle versioni, l'eliminazione ricorsiva è permanente. In un bucket abilitato al controllo delle versioni, aggiunge gli indicatori di eliminazione come descritto nella nota precedente. Usa per `-WhatIf` primo se non sei sicuro di cosa rimuoverà. Non è possibile eliminare un intero * bucket dall'unità perché * le operazioni relative al ciclo di vita del bucket non rientrano nell'ambito di applicazione. Usare invece [Remove-S3Bucket](https://docs.aws.amazon.com/powershell/v5/reference/items/Remove-S3Bucket.html). ## Assegna l'ambito di un'unità a un bucket o a un prefisso Monta con `-Root` per confinare un'unità in un bucket o un prefisso all'interno di un bucket. La radice dell'unità * è quindi * quella posizione e la navigazione è limitata al di sotto di essa. ``` # Mount rooted at a bucket: the drive root lists the bucket's top-level entries Mount-S3PSDrive -Name Data -Root amzn-s3-demo-bucket -ProfileName my-profile -Region us-east-1 Get-ChildItem Data:/ # top-level keys in amzn-s3-demo-bucket Get-Content Data:/reports/index.txt # -> amzn-s3-demo-bucket/reports/index.txt # Mount rooted at a bucket + prefix Mount-S3PSDrive -Name Reports -Root amzn-s3-demo-reports/2026 -ProfileName my-profile -Region us-east-1 Get-ChildItem Reports:/ # contents of amzn-s3-demo-reports/2026/ ``` La radice deve già esistere. Un bucket o un prefisso inesistente non riesce a eseguire il montaggio. Poiché i percorsi relativi non possono superare la radice (`..`è bloccato dal motore), un montaggio con ambito offre una visione mirata esattamente dei dati di un progetto. ## Accedi ai bucket tra le regioni da un'unica unità Una singola unità montata può raggiungere i bucket in tutte le regioni. La prima volta che tocchi un bucket, il provider cerca la sua regione e indirizza automaticamente le chiamate successive all'endpoint giusto. Non è necessaria un'unità separata per ogni regione. ``` # Mounted in us-east-1, but this bucket is in us-west-2 and commands work without extra configuration Mount-S3PSDrive -Name S3 -ProfileName my-profile -Region us-east-1 Get-ChildItem S3:/amzn-s3-demo-west-bucket Get-Content S3:/amzn-s3-demo-west-bucket/data/report.csv -Raw ``` ## Imposta una classe di archiviazione predefinita Imposta una classe di archiviazione predefinita a livello di unità al momento del montaggio con. `-StorageClass` Ogni caricamento tramite quell'unità utilizza la classe specificata a meno che una specifica non la `Set-Content` sovrascriva con una propria. `-StorageClass` ``` # Set all uploads to default to STANDARD_IA Mount-S3PSDrive -Name Archive -ProfileName my-profile -Region us-east-1 -StorageClass STANDARD_IA Set-Content Archive:/amzn-s3-demo-bucket/cold/data.txt -Value '...' # STANDARD_IA Set-Content Archive:/amzn-s3-demo-bucket/hot/data.txt -Value '...' -StorageClass STANDARD # overrides to STANDARD ``` ## Smonta un'unità Usa `Dismount-S3PSDrive` (un involucro sopra`Remove-PSDrive`) per rimuovere un'unità. Passa prima a un'altra posizione, perché PowerShell non rimuoverà un'unità che è la tua posizione attuale. ``` Set-Location $HOME # or C:\ on Windows Dismount-S3PSDrive -Name S3 ``` ## Operazioni supportate e non supportate Usa l'unità per sfogliare e spostare il * contenuto * degli oggetti. Il ciclo di vita dei bucket e le operazioni di copia lato server rimangono affidate ai cmdlet S3 dedicati. ### Supportata + Navigazione ed elenco:`Set-Location`, (incluso),,, completamento con schede `Get-ChildItem` `-Recurse` `Get-Item` `Test-Path` + Contenuto: `Get-Content` (download), `Set-Content` (upload) + Eliminazione: `Remove-Item` (oggetto singolo; prefissi con) `-Recurse` + Convogliare gli elementi elencati in e `Get-Content` `Remove-Item` ### Non supportata | Comando | Perché/cosa usare invece | | --- | --- | | `Copy-Item` | S3-to-S3 la copia non viene esposta attraverso l'unità. Da utilizzare [ Copy-S3Object ](https://docs.aws.amazon.com/powershell/v5/reference/items/Copy-S3Object.html) per copie sul lato server. Per trasferimenti da locale a S3 o trasferimenti, pipe. S3-to-local `Get-Content \| Set-Content` | | `Move-Item`, `Rename-Item` | S3 non può essere rinominato. Esegui una copia \+ cancellazione con i cmdlet. | | `New-Item`(directory) | S3 non ha cartelle reali. Viene visualizzato un prefisso quando si scrive un oggetto sotto di esso. | | `Clear-Content`, `Add-Content` | Gli oggetti sono scritti interi da`Set-Content`. Non è possibile aggiungere o cancellare sul posto. | | `Get-ItemProperty`, `Set-ItemProperty`, `Clear-ItemProperty` | L'unità non implementa l'interfaccia delle PowerShell proprietà, quindi questi comandi hanno esito negativo e viene visualizzato l'errore relativo all'interfaccia non supportata del PowerShell motore anziché il messaggio dell'unità. Gli articoli `Get-Item` restituiti riportano solo`Name`,, `Get-ChildItem` e. `Type` `Size` `LastModified` Per leggere o impostare i metadati degli oggetti S3, usa o. [ Get-S3ObjectMetadata ](https://docs.aws.amazon.com/powershell/v5/reference/items/Get-S3ObjectMetadata.html) [ Write-S3Object ](https://docs.aws.amazon.com/powershell/v5/reference/items/Write-S3Object.html) | | Creazione o eliminazione di bucket | Usa/[New-S3Bucket](https://docs.aws.amazon.com/powershell/v5/reference/items/New-S3Bucket.html). [ Remove-S3Bucket ](https://docs.aws.amazon.com/powershell/v5/reference/items/Remove-S3Bucket.html) | I comandi non supportati hanno esito negativo e viene visualizzato un messaggio che nomina il comando e punta all'alternativa, ad esempio, "non Copy-Item è supportato dall'unità S3. Usa Copy-S3Object, o reindirizzalo Get-Content a Set-Content». I `*-ItemProperty` comandi sono l'eccezione, come descritto nella tabella precedente. ## Riferimento ai comandi Per l'elenco completo dei parametri per [ Mount-S3PSDrive ](https://docs.aws.amazon.com/powershell/v5/reference/items/Mount-S3PSDrive.html) e [ Dismount-S3PSDrive](https://docs.aws.amazon.com/powershell/v5/reference/items/Dismount-S3PSDrive.html), vedere il [AWS Strumenti per PowerShell Cmdlet Reference. ](https://docs.aws.amazon.com/powershell/v5/reference/) In un percorso S3, l'unità aggiunge anche parametri dinamici `Set-Content` che non sono `Get-Content` inclusi nella PowerShell documentazione di tali cmdlet: | Comando | Parameters | | --- | --- | | `Get-Content` | `-AsByteStream`, `-Raw`, `-Encoding`, `-PartSize` | | `Set-Content` | `-AsByteStream`,`-Encoding`,`-NoNewline`,`-StorageClass`, `-PartSize` (vedi[Carica oggetti molto grandi](#pstools-s3-drive-large-objects)) | ## Risoluzione dei problemi ### «Impossibile smontare l'unità perché è in uso». L'unità S3 è la posizione corrente. Passa a una posizione su un'altra unità, ad esempio`$HOME`, e poi esegui di `Dismount-S3PSDrive` nuovo. ### Il montaggio non riesce con il messaggio «root non è stato trovato o non è raggiungibile». Il bucket o il prefisso in `-Root` non esiste. Controlla il nome (e la regione, se il bucket è incluso in uno in cui le tue credenziali non sono predefinite). Un * errore di * credenziale produce un errore diverso, non questo messaggio «non raggiungibile». Un errore di autorizzazione nella cartella principale potrebbe non apparire finché non si accede a un oggetto, quindi un montaggio riuscito non garantisce la possibilità di leggere tutti i percorsi al suo interno. ### L'eliminazione di un prefisso non vuoto si blocca in uno script. Ciò accade quando si elimina un prefisso * non vuoto senza. * `-Recurse` Il PowerShell motore genera una richiesta di conferma perché il prefisso ha figli (il comportamento container-has-children del provider del file system). Un host non interattivo non può rispondere al prompt, quindi il comando si blocca. Passa `-Recurse` per eliminare il contenuto del prefisso senza chiedere conferma o conferma in modo interattivo per procedere. (non `-Force` viene consultato dal percorso di eliminazione dell'unità, quindi non ha alcun effetto qui.) ### «Un oggetto che ho appena modificato all'esterno dell'unità mostra ancora il vecchio elenco». Le inserzioni vengono memorizzate brevemente nella cache (circa un secondo) per mantenere la navigazione veloce. Le modifiche apportate * tramite * l'unità vengono visualizzate immediatamente. Le modifiche apportate da un altro strumento vengono visualizzate dopo la scadenza della cache breve. ### «Una chiave contiene una barra rovesciata». La capacità dell'unità di indirizzare una chiave che contiene una barra rovesciata dipende dal sistema operativo, poiché l'unità accetta il separatore di percorso nativo della piattaforma: + **Windows**: `\` è un separatore di percorso, quindi l'unità lo legge come tale e lo normalizza. `/` Una chiave che contiene una barra rovesciata letterale non può essere indirizzata tramite l'unità. Utilizza invece i cmdlet S3, ad esempio o. [ Get-S3Object ](https://docs.aws.amazon.com/powershell/v5/reference/items/Get-S3Object.html) [ Read-S3Object ](https://docs.aws.amazon.com/powershell/v5/reference/items/Read-S3Object.html) + **Linux e macOS**: `/` è solo un separatore di percorso. Una barra rovesciata è un carattere normale in una chiave, quindi l'unità indirizza normalmente quei tasti. **Consulta anche** + [Cosa sono gli AWS Strumenti per PowerShell?](pstools-welcome.md) + [AWS Strumenti per PowerShell Riferimento al cmdlet ](https://docs.aws.amazon.com/powershell/v5/reference/) + [Documentazione Amazon S3 ](https://docs.aws.amazon.com/s3/)