Sono disponibili altri esempi AWS SDK nel repository [AWS Doc SDK](https://github.com/awsdocs/aws-doc-sdk-examples) Examples. GitHub
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à.
# Esempi di base per l'utilizzo di Amazon Glacier AWS SDKs
I seguenti esempi di codice mostrano come utilizzare le nozioni di base di Amazon AWS SDKs Glacier con.
**Contents**
+ [Ciao Amazon Glacier](glacier_example_glacier_Hello_section.md)
+ [Azioni](glacier_code_examples_actions.md)
+ [`AddTagsToVault`](glacier_example_glacier_AddTagsToVault_section.md)
+ [`CreateVault`](glacier_example_glacier_CreateVault_section.md)
+ [`DeleteArchive`](glacier_example_glacier_DeleteArchive_section.md)
+ [`DeleteVault`](glacier_example_glacier_DeleteVault_section.md)
+ [`DeleteVaultNotifications`](glacier_example_glacier_DeleteVaultNotifications_section.md)
+ [`DescribeJob`](glacier_example_glacier_DescribeJob_section.md)
+ [`DescribeVault`](glacier_example_glacier_DescribeVault_section.md)
+ [`GetJobOutput`](glacier_example_glacier_GetJobOutput_section.md)
+ [`GetVaultNotifications`](glacier_example_glacier_GetVaultNotifications_section.md)
+ [`InitiateJob`](glacier_example_glacier_InitiateJob_section.md)
+ [`ListJobs`](glacier_example_glacier_ListJobs_section.md)
+ [`ListTagsForVault`](glacier_example_glacier_ListTagsForVault_section.md)
+ [`ListVaults`](glacier_example_glacier_ListVaults_section.md)
+ [`SetVaultNotifications`](glacier_example_glacier_SetVaultNotifications_section.md)
+ [`UploadArchive`](glacier_example_glacier_UploadArchive_section.md)
+ [`UploadMultipartPart`](glacier_example_glacier_UploadMultipartPart_section.md)
# Ciao Amazon Glacier
Il seguente esempio di codice mostra come iniziare a usare Amazon Glacier.
------
#### [ .NET ]
**SDK per .NET**
C'è altro su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/EventBridge#code-examples).
```
using Amazon.Glacier;
using Amazon.Glacier.Model;
namespace GlacierActions;
public static class HelloGlacier
{
static async Task Main()
{
var glacierService = new AmazonGlacierClient();
Console.WriteLine("Hello Amazon Glacier!");
Console.WriteLine("Let's list your Glacier vaults:");
// You can use await and any of the async methods to get a response.
// Let's get the vaults using a paginator.
var glacierVaultPaginator = glacierService.Paginators.ListVaults(
new ListVaultsRequest { AccountId = "-" });
await foreach (var vault in glacierVaultPaginator.VaultList)
{
Console.WriteLine($"{vault.CreationDate}:{vault.VaultName}, ARN:{vault.VaultARN}");
}
}
}
```
+ Per i dettagli sull'API, [ListVaults](https://docs.aws.amazon.com/goto/DotNetSDKV3/glacier-2012-06-01/ListVaults)consulta *AWS SDK per .NET API Reference*.
------
# Azioni per l'utilizzo di Amazon Glacier AWS SDKs
I seguenti esempi di codice mostrano come eseguire singole azioni di Amazon Glacier con. AWS SDKs Ogni esempio include un collegamento a GitHub, dove puoi trovare le istruzioni per la configurazione e l'esecuzione del codice.
Questi estratti chiamano l'API Amazon Glacier e sono estratti di codice da programmi più grandi che devono essere eseguiti nel contesto. È possibile visualizzare le azioni nel contesto in [Scenari per l'utilizzo di Amazon Glacier AWS SDKs](glacier_code_examples_scenarios.md).
Gli esempi seguenti includono solo le azioni più comunemente utilizzate. Per un elenco completo, consulta l'[Amazon Glacier API Reference](https://docs.aws.amazon.com/amazonglacier/latest/dev/amazon-glacier-api.html).
**Topics**
+ [`AddTagsToVault`](glacier_example_glacier_AddTagsToVault_section.md)
+ [`CreateVault`](glacier_example_glacier_CreateVault_section.md)
+ [`DeleteArchive`](glacier_example_glacier_DeleteArchive_section.md)
+ [`DeleteVault`](glacier_example_glacier_DeleteVault_section.md)
+ [`DeleteVaultNotifications`](glacier_example_glacier_DeleteVaultNotifications_section.md)
+ [`DescribeJob`](glacier_example_glacier_DescribeJob_section.md)
+ [`DescribeVault`](glacier_example_glacier_DescribeVault_section.md)
+ [`GetJobOutput`](glacier_example_glacier_GetJobOutput_section.md)
+ [`GetVaultNotifications`](glacier_example_glacier_GetVaultNotifications_section.md)
+ [`InitiateJob`](glacier_example_glacier_InitiateJob_section.md)
+ [`ListJobs`](glacier_example_glacier_ListJobs_section.md)
+ [`ListTagsForVault`](glacier_example_glacier_ListTagsForVault_section.md)
+ [`ListVaults`](glacier_example_glacier_ListVaults_section.md)
+ [`SetVaultNotifications`](glacier_example_glacier_SetVaultNotifications_section.md)
+ [`UploadArchive`](glacier_example_glacier_UploadArchive_section.md)
+ [`UploadMultipartPart`](glacier_example_glacier_UploadMultipartPart_section.md)
# Utilizzo `AddTagsToVault` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `AddTagsToVault`.
------
#### [ .NET ]
**SDK per .NET**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Glacier#code-examples).
```
///
/// Add tags to the items in an Amazon S3 Glacier vault.
///
/// The name of the vault to add tags to.
/// The name of the object to tag.
/// The tag value to add.
/// A Boolean value indicating the success of the action.
public async Task AddTagsToVaultAsync(string vaultName, string key, string value)
{
var request = new AddTagsToVaultRequest
{
Tags = new Dictionary
{
{ key, value },
},
AccountId = "-",
VaultName = vaultName,
};
var response = await _glacierService.AddTagsToVaultAsync(request);
return response.HttpStatusCode == HttpStatusCode.NoContent;
}
```
+ Per i dettagli sull'API, [AddTagsToVault](https://docs.aws.amazon.com/goto/DotNetSDKV3/glacier-2012-06-01/AddTagsToVault)consulta *AWS SDK per .NET API Reference*.
------
#### [ CLI ]
**AWS CLI**
Il comando seguente aggiunge due tag a un vault denominato `my-vault`:
```
aws glacier add-tags-to-vault --account-id - --vault-name my-vault --tags id=1234,date=july2015
```
Amazon Glacier richiede un argomento ID account durante l’esecuzione delle operazioni, ma puoi utilizzare un trattino per specificare l’account in uso.
+ Per i dettagli sull'API, consulta [AddTagsToVault AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glacier/add-tags-to-vault.html)*Command Reference*.
------
# Utilizzo `CreateVault` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `CreateVault`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nel seguente esempio di codice:
+ [Archiviazione di un file, ricezione di notifiche e avvio di processo](glacier_example_glacier_Usage_UploadNotifyInitiate_section.md)
------
#### [ .NET ]
**SDK per .NET**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Glacier#code-examples).
```
///
/// Create an Amazon S3 Glacier vault.
///
/// The name of the vault to create.
/// A Boolean value indicating the success of the action.
public async Task CreateVaultAsync(string vaultName)
{
var request = new CreateVaultRequest
{
// Setting the AccountId to "-" means that
// the account associated with the current
// account will be used.
AccountId = "-",
VaultName = vaultName,
};
var response = await _glacierService.CreateVaultAsync(request);
Console.WriteLine($"Created {vaultName} at: {response.Location}");
return response.HttpStatusCode == HttpStatusCode.Created;
}
```
+ Per i dettagli sull'API, [CreateVault](https://docs.aws.amazon.com/goto/DotNetSDKV3/glacier-2012-06-01/CreateVault)consulta *AWS SDK per .NET API Reference*.
------
#### [ CLI ]
**AWS CLI**
Il comando seguente crea un nuovo vault denominato `my-vault`:
```
aws glacier create-vault --vault-name my-vault --account-id -
```
Amazon Glacier richiede un argomento ID account durante l’esecuzione delle operazioni, ma puoi utilizzare un trattino per specificare l’account in uso.
+ Per i dettagli sull'API, consulta [CreateVault AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glacier/create-vault.html)*Command Reference*.
------
#### [ Java ]
**SDK per Java 2.x**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/glacier#code-examples).
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.glacier.GlacierClient;
import software.amazon.awssdk.services.glacier.model.CreateVaultRequest;
import software.amazon.awssdk.services.glacier.model.CreateVaultResponse;
import software.amazon.awssdk.services.glacier.model.GlacierException;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class CreateVault {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
vaultName - The name of the vault to create.
""";
if (args.length != 1) {
System.out.println(usage);
System.exit(1);
}
String vaultName = args[0];
GlacierClient glacier = GlacierClient.builder()
.region(Region.US_EAST_1)
.build();
createGlacierVault(glacier, vaultName);
glacier.close();
}
public static void createGlacierVault(GlacierClient glacier, String vaultName) {
try {
CreateVaultRequest vaultRequest = CreateVaultRequest.builder()
.vaultName(vaultName)
.build();
CreateVaultResponse createVaultResult = glacier.createVault(vaultRequest);
System.out.println("The URI of the new vault is " + createVaultResult.location());
} catch (GlacierException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
+ Per i dettagli sull'API, [CreateVault](https://docs.aws.amazon.com/goto/SdkForJavaV2/glacier-2012-06-01/CreateVault)consulta *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK per JavaScript (v3)**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/glacier#code-examples).
Crea il client.
```
const { GlacierClient } = require("@aws-sdk/client-glacier");
// Set the AWS Region.
const REGION = "REGION";
//Set the Redshift Service Object
const glacierClient = new GlacierClient({ region: REGION });
export { glacierClient };
```
Crea la vault.
```
// Load the SDK for JavaScript
import { CreateVaultCommand } from "@aws-sdk/client-glacier";
import { glacierClient } from "./libs/glacierClient.js";
// Set the parameters
const vaultname = "VAULT_NAME"; // VAULT_NAME
const params = { vaultName: vaultname };
const run = async () => {
try {
const data = await glacierClient.send(new CreateVaultCommand(params));
console.log("Success, vault created!");
return data; // For unit tests.
} catch (err) {
console.log("Error");
}
};
run();
```
+ Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS SDK per JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/glacier-example-creating-a-vault.html).
+ Per i dettagli sull'API, [CreateVault](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/glacier/command/CreateVaultCommand)consulta *AWS SDK per JavaScript API Reference*.
**SDK per JavaScript (v2)**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascript/example_code/glacier#code-examples).
```
// Load the SDK for JavaScript
var AWS = require("aws-sdk");
// Set the region
AWS.config.update({ region: "REGION" });
// Create a new service object
var glacier = new AWS.Glacier({ apiVersion: "2012-06-01" });
// Call Glacier to create the vault
glacier.createVault({ vaultName: "YOUR_VAULT_NAME" }, function (err) {
if (!err) {
console.log("Created vault!");
}
});
```
+ Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS SDK per JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/glacier-example-creating-a-vault.html).
+ Per i dettagli sull'API, [CreateVault](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/glacier-2012-06-01/CreateVault)consulta *AWS SDK per JavaScript API Reference*.
------
#### [ PowerShell ]
**Strumenti per PowerShell V4**
**Esempio 1: crea un nuovo vault per l’account dell’utente. Poiché non è stato fornito alcun valore al AccountId parametro -, i cmdlet utilizzano un valore predefinito di «-» che indica l'account corrente.**
```
New-GLCVault -VaultName myvault
```
**Output:**
```
/01234567812/vaults/myvault
```
+ Per i dettagli sull'API, vedere [CreateVault](https://docs.aws.amazon.com/powershell/v4/reference)in *AWS Strumenti per PowerShell Cmdlet Reference* (V4).
**Strumenti per V5 PowerShell **
**Esempio 1: crea un nuovo vault per l’account dell’utente. Poiché non è stato fornito alcun valore al AccountId parametro -, i cmdlet utilizzano un valore predefinito di «-» che indica l'account corrente.**
```
New-GLCVault -VaultName myvault
```
**Output:**
```
/01234567812/vaults/myvault
```
+ Per i dettagli sull'API, vedere [CreateVault](https://docs.aws.amazon.com/powershell/v5/reference)in *AWS Strumenti per PowerShell Cmdlet Reference* (V5).
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è altro su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/glacier#code-examples).
```
class GlacierWrapper:
"""Encapsulates Amazon S3 Glacier API operations."""
def __init__(self, glacier_resource):
"""
:param glacier_resource: A Boto3 Amazon S3 Glacier resource.
"""
self.glacier_resource = glacier_resource
def create_vault(self, vault_name):
"""
Creates a vault.
:param vault_name: The name to give the vault.
:return: The newly created vault.
"""
try:
vault = self.glacier_resource.create_vault(vaultName=vault_name)
logger.info("Created vault %s.", vault_name)
except ClientError:
logger.exception("Couldn't create vault %s.", vault_name)
raise
else:
return vault
```
+ Per i dettagli sull'API, consulta [CreateVault AWS](https://docs.aws.amazon.com/goto/boto3/glacier-2012-06-01/CreateVault)*SDK for Python (Boto3) API Reference*.
------
# Utilizzo `DeleteArchive` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `DeleteArchive`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nel seguente esempio di codice:
+ [Come ottenere i contenuti dell’archivio ed eliminare l’archivio](glacier_example_glacier_Usage_RetrieveDelete_section.md)
------
#### [ CLI ]
**AWS CLI**
**Eliminazione di un archivio da un vault**
L’esempio `delete-archive` seguente rimuove l’archivio specificato da `example_vault`.
```
aws glacier delete-archive \
--account-id 111122223333 \
--vault-name example_vault \
--archive-id Sc0u9ZP8yaWkmh-XGlIvAVprtLhaLCGnNwNl5I5x9HqPIkX5mjc0DrId3Ln-Gi_k2HzmlIDZUz117KSdVMdMXLuFWi9PJUitxWO73edQ43eTlMWkH0pd9zVSAuV_XXZBVhKhyGhJ7w
```
Questo comando non produce alcun output.
+ Per i dettagli sull'API, consulta [DeleteArchive AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glacier/delete-archive.html)*Command Reference.*
------
#### [ Java ]
**SDK per Java 2.x**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/glacier#code-examples).
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.glacier.GlacierClient;
import software.amazon.awssdk.services.glacier.model.DeleteArchiveRequest;
import software.amazon.awssdk.services.glacier.model.GlacierException;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class DeleteArchive {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
vaultName - The name of the vault that contains the archive to delete.
accountId - The account ID value.
archiveId - The archive ID value.
""";
if (args.length != 3) {
System.out.println(usage);
System.exit(1);
}
String vaultName = args[0];
String accountId = args[1];
String archiveId = args[2];
GlacierClient glacier = GlacierClient.builder()
.region(Region.US_EAST_1)
.build();
deleteGlacierArchive(glacier, vaultName, accountId, archiveId);
glacier.close();
}
public static void deleteGlacierArchive(GlacierClient glacier, String vaultName, String accountId,
String archiveId) {
try {
DeleteArchiveRequest delArcRequest = DeleteArchiveRequest.builder()
.vaultName(vaultName)
.accountId(accountId)
.archiveId(archiveId)
.build();
glacier.deleteArchive(delArcRequest);
System.out.println("The archive was deleted.");
} catch (GlacierException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
+ Per i dettagli sull'API, [DeleteArchive](https://docs.aws.amazon.com/goto/SdkForJavaV2/glacier-2012-06-01/DeleteArchive)consulta *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/glacier#code-examples).
```
class GlacierWrapper:
"""Encapsulates Amazon S3 Glacier API operations."""
def __init__(self, glacier_resource):
"""
:param glacier_resource: A Boto3 Amazon S3 Glacier resource.
"""
self.glacier_resource = glacier_resource
@staticmethod
def delete_archive(archive):
"""
Deletes an archive from a vault.
:param archive: The archive to delete.
"""
try:
archive.delete()
logger.info(
"Deleted archive %s from vault %s.", archive.id, archive.vault_name
)
except ClientError:
logger.exception("Couldn't delete archive %s.", archive.id)
raise
```
+ Per i dettagli sull'API, consulta [DeleteArchive AWS](https://docs.aws.amazon.com/goto/boto3/glacier-2012-06-01/DeleteArchive)*SDK for Python (Boto3) API Reference*.
------
# Utilizzo `DeleteVault` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `DeleteVault`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nel seguente esempio di codice:
+ [Come ottenere i contenuti dell’archivio ed eliminare l’archivio](glacier_example_glacier_Usage_RetrieveDelete_section.md)
------
#### [ CLI ]
**AWS CLI**
Il comando seguente elimina un vault denominato `my-vault`:
```
aws glacier delete-vault --vault-name my-vault --account-id -
```
Il comando non produce output. Amazon Glacier richiede un argomento ID account durante l’esecuzione delle operazioni, ma puoi utilizzare un trattino per specificare l’account in uso.
+ Per i dettagli sull'API, consulta [DeleteVault AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glacier/delete-vault.html)*Command Reference.*
------
#### [ Java ]
**SDK per Java 2.x**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/glacier#code-examples).
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.glacier.GlacierClient;
import software.amazon.awssdk.services.glacier.model.DeleteVaultRequest;
import software.amazon.awssdk.services.glacier.model.GlacierException;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class DeleteVault {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
vaultName - The name of the vault to delete.\s
""";
if (args.length != 1) {
System.out.println(usage);
System.exit(1);
}
String vaultName = args[0];
GlacierClient glacier = GlacierClient.builder()
.region(Region.US_EAST_1)
.build();
deleteGlacierVault(glacier, vaultName);
glacier.close();
}
public static void deleteGlacierVault(GlacierClient glacier, String vaultName) {
try {
DeleteVaultRequest delVaultRequest = DeleteVaultRequest.builder()
.vaultName(vaultName)
.build();
glacier.deleteVault(delVaultRequest);
System.out.println("The vault was deleted!");
} catch (GlacierException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
+ Per i dettagli sull'API, [DeleteVault](https://docs.aws.amazon.com/goto/SdkForJavaV2/glacier-2012-06-01/DeleteVault)consulta *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/glacier#code-examples).
```
class GlacierWrapper:
"""Encapsulates Amazon S3 Glacier API operations."""
def __init__(self, glacier_resource):
"""
:param glacier_resource: A Boto3 Amazon S3 Glacier resource.
"""
self.glacier_resource = glacier_resource
@staticmethod
def delete_vault(vault):
"""
Deletes a vault.
:param vault: The vault to delete.
"""
try:
vault.delete()
logger.info("Deleted vault %s.", vault.name)
except ClientError:
logger.exception("Couldn't delete vault %s.", vault.name)
raise
```
+ Per i dettagli sull'API, consulta [DeleteVault AWS](https://docs.aws.amazon.com/goto/boto3/glacier-2012-06-01/DeleteVault)*SDK for Python (Boto3) API Reference*.
------
# Utilizzo `DeleteVaultNotifications` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `DeleteVaultNotifications`.
------
#### [ CLI ]
**AWS CLI**
**Rimuovere le notifiche SNS per un vault**
L’esempio `delete-vault-notifications` seguente rimuove le notifiche inviate da Amazon Simple Notification Service (Amazon SNS) per la vault specificata.
```
aws glacier delete-vault-notifications \
--account-id 111122223333 \
--vault-name example_vault
```
Questo comando non produce alcun output.
+ Per i dettagli sull'API, consulta [DeleteVaultNotifications AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glacier/delete-vault-notifications.html)*Command Reference.*
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/glacier#code-examples).
```
class GlacierWrapper:
"""Encapsulates Amazon S3 Glacier API operations."""
def __init__(self, glacier_resource):
"""
:param glacier_resource: A Boto3 Amazon S3 Glacier resource.
"""
self.glacier_resource = glacier_resource
@staticmethod
def stop_notifications(notification):
"""
Stops notifications to the configured Amazon SNS topic.
:param notification: The notification configuration to remove.
"""
try:
notification.delete()
logger.info("Notifications stopped.")
except ClientError:
logger.exception("Couldn't stop notifications.")
raise
```
+ Per i dettagli sull'API, consulta [DeleteVaultNotifications AWS](https://docs.aws.amazon.com/goto/boto3/glacier-2012-06-01/DeleteVaultNotifications)*SDK for Python (Boto3) API Reference*.
------
# Utilizzo `DescribeJob` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `DescribeJob`.
------
#### [ CLI ]
**AWS CLI**
Il comando seguente recupera le informazioni su un processo di recupero dell’inventario su un vault denominato `my-vault`:
```
aws glacier describe-job --account-id - --vault-name my-vault --job-id zbxcm3Z_3z5UkoroF7SuZKrxgGoDc3RloGduS7Eg-RO47Yc6FxsdGBgf_Q2DK5Ejh18CnTS5XW4_XqlNHS61dsO4CnMW
```
Output:
```
{
"InventoryRetrievalParameters": {
"Format": "JSON"
},
"VaultARN": "arn:aws:glacier:us-west-2:0123456789012:vaults/my-vault",
"Completed": false,
"JobId": "zbxcm3Z_3z5UkoroF7SuZKrxgGoDc3RloGduS7Eg-RO47Yc6FxsdGBgf_Q2DK5Ejh18CnTS5XW4_XqlNHS61dsO4CnMW",
"Action": "InventoryRetrieval",
"CreationDate": "2015-07-17T20:23:41.616Z",
"StatusCode": "InProgress"
}
```
L’ID del processo si trova nell’output di `aws glacier initiate-job` e `aws glacier list-jobs`. Amazon Glacier richiede un argomento ID account durante l’esecuzione delle operazioni, ma puoi utilizzare un trattino per specificare l’account in uso.
+ Per i dettagli sull'API, consulta [DescribeJob AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glacier/describe-job.html)*Command Reference.*
------
#### [ PowerShell ]
**Strumenti per PowerShell V4**
**Esempio 1: restituisce i dettagli del processo specificato. Quando il processo viene completato correttamente, è possibile utilizzare il cmdlet GCJob Read-Output per recuperare il contenuto del processo (un archivio o un elenco di inventario) nel file system locale.**
```
Get-GLCJob -VaultName myvault -JobId "op1x...JSbthM"
```
**Output:**
```
Action : ArchiveRetrieval
ArchiveId : o9O9j...X-TpIhQJw
ArchiveSHA256TreeHash : 79f3ea754c02f58...dc57bf4395b
ArchiveSizeInBytes : 38034480
Completed : False
CompletionDate : 1/1/0001 12:00:00 AM
CreationDate : 12/13/2018 11:00:14 AM
InventoryRetrievalParameters :
InventorySizeInBytes : 0
JobDescription :
JobId : op1x...JSbthM
JobOutputPath :
OutputLocation :
RetrievalByteRange : 0-38034479
SelectParameters :
SHA256TreeHash : 79f3ea754c02f58...dc57bf4395b
SNSTopic :
StatusCode : InProgress
StatusMessage :
Tier : Standard
VaultARN : arn:aws:glacier:us-west-2:012345678912:vaults/test
```
+ Per i dettagli sull'API, vedere [DescribeJob](https://docs.aws.amazon.com/powershell/v4/reference)in *AWS Strumenti per PowerShell Cmdlet* Reference (V4).
**Strumenti per V5 PowerShell **
**Esempio 1: restituisce i dettagli del processo specificato. Quando il processo viene completato correttamente, è possibile utilizzare il cmdlet GCJob Read-Output per recuperare il contenuto del processo (un archivio o un elenco di inventario) nel file system locale.**
```
Get-GLCJob -VaultName myvault -JobId "op1x...JSbthM"
```
**Output:**
```
Action : ArchiveRetrieval
ArchiveId : o9O9j...X-TpIhQJw
ArchiveSHA256TreeHash : 79f3ea754c02f58...dc57bf4395b
ArchiveSizeInBytes : 38034480
Completed : False
CompletionDate : 1/1/0001 12:00:00 AM
CreationDate : 12/13/2018 11:00:14 AM
InventoryRetrievalParameters :
InventorySizeInBytes : 0
JobDescription :
JobId : op1x...JSbthM
JobOutputPath :
OutputLocation :
RetrievalByteRange : 0-38034479
SelectParameters :
SHA256TreeHash : 79f3ea754c02f58...dc57bf4395b
SNSTopic :
StatusCode : InProgress
StatusMessage :
Tier : Standard
VaultARN : arn:aws:glacier:us-west-2:012345678912:vaults/test
```
+ Per i dettagli sull'API, vedere [DescribeJob](https://docs.aws.amazon.com/powershell/v5/reference)in *AWS Strumenti per PowerShell Cmdlet* Reference (V5).
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è altro su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/glacier#code-examples).
```
class GlacierWrapper:
"""Encapsulates Amazon S3 Glacier API operations."""
def __init__(self, glacier_resource):
"""
:param glacier_resource: A Boto3 Amazon S3 Glacier resource.
"""
self.glacier_resource = glacier_resource
@staticmethod
def get_job_status(job):
"""
Gets the status of a job.
:param job: The job to query.
:return: The current status of the job.
"""
try:
job.load()
logger.info(
"Job %s is performing action %s and has status %s.",
job.id,
job.action,
job.status_code,
)
except ClientError:
logger.exception("Couldn't get status for job %s.", job.id)
raise
else:
return job.status_code
```
+ Per i dettagli sull'API, consulta [DescribeJob AWS](https://docs.aws.amazon.com/goto/boto3/glacier-2012-06-01/DescribeJob)*SDK for Python (Boto3) API Reference*.
------
# Utilizzo `DescribeVault` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `DescribeVault`.
------
#### [ .NET ]
**SDK per .NET**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Glacier#code-examples).
```
///
/// Describe an Amazon S3 Glacier vault.
///
/// The name of the vault to describe.
/// The Amazon Resource Name (ARN) of the vault.
public async Task DescribeVaultAsync(string vaultName)
{
var request = new DescribeVaultRequest
{
AccountId = "-",
VaultName = vaultName,
};
var response = await _glacierService.DescribeVaultAsync(request);
// Display the information about the vault.
Console.WriteLine($"{response.VaultName}\tARN: {response.VaultARN}");
Console.WriteLine($"Created on: {response.CreationDate}\tNumber of Archives: {response.NumberOfArchives}\tSize (in bytes): {response.SizeInBytes}");
if (response.LastInventoryDate != DateTime.MinValue)
{
Console.WriteLine($"Last inventory: {response.LastInventoryDate}");
}
return response.VaultARN;
}
```
+ Per i dettagli sull'API, [DescribeVault](https://docs.aws.amazon.com/goto/DotNetSDKV3/glacier-2012-06-01/DescribeVault)consulta *AWS SDK per .NET API Reference*.
------
#### [ CLI ]
**AWS CLI**
Il comando seguente recupera i dati relativi a un vault denominato `my-vault`:
```
aws glacier describe-vault --vault-name my-vault --account-id -
```
Amazon Glacier richiede un argomento ID account durante l’esecuzione delle operazioni, ma puoi utilizzare un trattino per specificare l’account in uso.
+ Per i dettagli sull'API, consulta [DescribeVault AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glacier/describe-vault.html)*Command Reference*.
------
# Utilizzo `GetJobOutput` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `GetJobOutput`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nel seguente esempio di codice:
+ [Come ottenere i contenuti dell’archivio ed eliminare l’archivio](glacier_example_glacier_Usage_RetrieveDelete_section.md)
------
#### [ CLI ]
**AWS CLI**
Il comando seguente salva l’output di un processo di inventario della vault in un file nella directory corrente denominata `output.json`:
```
aws glacier get-job-output --account-id - --vault-name my-vault --job-id zbxcm3Z_3z5UkoroF7SuZKrxgGoDc3RloGduS7Eg-RO47Yc6FxsdGBgf_Q2DK5Ejh18CnTS5XW4_XqlNHS61dsO4CnMW output.json
```
`job-id` è disponibile nell’output di `aws glacier list-jobs`. Nota che il nome del file di output è un argomento posizionale non preceduto dal nome di un’opzione. Amazon Glacier richiede un argomento ID account durante l'esecuzione delle operazioni, ma puoi utilizzare un trattino per specificare l'account in uso.
Output:
```
{
"status": 200,
"acceptRanges": "bytes",
"contentType": "application/json"
}
```
`output.json`:
```
{"VaultARN":"arn:aws:glacier:us-west-2:0123456789012:vaults/my-vault","InventoryDate":"2015-04-07T00:26:18Z","ArchiveList":[{"ArchiveId":"kKB7ymWJVpPSwhGP6ycSOAekp9ZYe_--zM_mw6k76ZFGEIWQX-ybtRDvc2VkPSDtfKmQrj0IRQLSGsNuDp-AJVlu2ccmDSyDUmZwKbwbpAdGATGDiB3hHO0bjbGehXTcApVud_wyDw","ArchiveDescription":"multipart upload test","CreationDate":"2015-04-06T22:24:34Z","Size":3145728,"SHA256TreeHash":"9628195fcdbcbbe76cdde932d4646fa7de5f219fb39823836d81f0cc0e18aa67"}]}
```
+ Per i dettagli sull'API, consulta [GetJobOutput AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glacier/get-job-output.html)*Command Reference.*
------
#### [ PowerShell ]
**Strumenti per PowerShell V4**
**Esempio 1: scarica il contenuto dell’archivio di cui è stato pianificato il recupero nel processo specificato e lo archivia in un file su disco. Il download convalida automaticamente il checksum, se disponibile. Se lo si desidera, è possibile restituire l’intera risposta, incluso il checksum, specificando `-Select '*'`.**
```
Read-GLCJobOutput -VaultName myvault -JobId "HSWjArc...Zq2XLiW" -FilePath "c:\temp\blue.bin"
```
+ Per i dettagli sull'API, vedere [GetJobOutput](https://docs.aws.amazon.com/powershell/v4/reference)in *AWS Strumenti per PowerShell Cmdlet Reference (*V4).
**Strumenti per V5 PowerShell **
**Esempio 1: scarica il contenuto dell’archivio di cui è stato pianificato il recupero nel processo specificato e lo archivia in un file su disco. Il download convalida automaticamente il checksum, se disponibile. Se lo si desidera, è possibile restituire l’intera risposta, incluso il checksum, specificando `-Select '*'`.**
```
Read-GLCJobOutput -VaultName myvault -JobId "HSWjArc...Zq2XLiW" -FilePath "c:\temp\blue.bin"
```
+ Per i dettagli sull'API, vedere [GetJobOutput](https://docs.aws.amazon.com/powershell/v5/reference)in *AWS Strumenti per PowerShell Cmdlet Reference (*V5).
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è altro su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/glacier#code-examples).
```
class GlacierWrapper:
"""Encapsulates Amazon S3 Glacier API operations."""
def __init__(self, glacier_resource):
"""
:param glacier_resource: A Boto3 Amazon S3 Glacier resource.
"""
self.glacier_resource = glacier_resource
@staticmethod
def get_job_output(job):
"""
Gets the output of a job, such as a vault inventory or the contents of an
archive.
:param job: The job to get output from.
:return: The job output, in bytes.
"""
try:
response = job.get_output()
out_bytes = response["body"].read()
logger.info("Read %s bytes from job %s.", len(out_bytes), job.id)
if "archiveDescription" in response:
logger.info(
"These bytes are described as '%s'", response["archiveDescription"]
)
except ClientError:
logger.exception("Couldn't get output for job %s.", job.id)
raise
else:
return out_bytes
```
+ Per i dettagli sull'API, consulta [GetJobOutput AWS](https://docs.aws.amazon.com/goto/boto3/glacier-2012-06-01/GetJobOutput)*SDK for Python (Boto3) API Reference*.
------
# Utilizzo `GetVaultNotifications` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `GetVaultNotifications`.
------
#### [ CLI ]
**AWS CLI**
Il comando seguente ottiene una descrizione della configurazione della notifica per un vault denominato `my-vault`:
```
aws glacier get-vault-notifications --account-id - --vault-name my-vault
```
Output:
```
{
"vaultNotificationConfig": {
"Events": [
"InventoryRetrievalCompleted",
"ArchiveRetrievalCompleted"
],
"SNSTopic": "arn:aws:sns:us-west-2:0123456789012:my-vault"
}
}
```
Se non è stata configurata alcuna notifica per il vault, viene restituito un errore. Amazon Glacier richiede un argomento ID account durante l’esecuzione delle operazioni, ma puoi utilizzare un trattino per specificare l’account in uso.
+ Per i dettagli sull'API, consulta [GetVaultNotifications AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glacier/get-vault-notifications.html)*Command Reference.*
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/glacier#code-examples).
```
class GlacierWrapper:
"""Encapsulates Amazon S3 Glacier API operations."""
def __init__(self, glacier_resource):
"""
:param glacier_resource: A Boto3 Amazon S3 Glacier resource.
"""
self.glacier_resource = glacier_resource
@staticmethod
def get_notification(vault):
"""
Gets the currently notification configuration for a vault.
:param vault: The vault to query.
:return: The notification configuration for the specified vault.
"""
try:
notification = vault.Notification()
logger.info(
"Vault %s notifies %s on %s events.",
vault.name,
notification.sns_topic,
notification.events,
)
except ClientError:
logger.exception("Couldn't get notification data for %s.", vault.name)
raise
else:
return notification
```
+ Per i dettagli sull'API, consulta [GetVaultNotifications AWS](https://docs.aws.amazon.com/goto/boto3/glacier-2012-06-01/GetVaultNotifications)*SDK for Python (Boto3) API Reference*.
------
# Utilizzo `InitiateJob` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `InitiateJob`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nel seguente esempio di codice:
+ [Archiviazione di un file, ricezione di notifiche e avvio di processo](glacier_example_glacier_Usage_UploadNotifyInitiate_section.md)
------
#### [ .NET ]
**SDK per .NET**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Glacier#code-examples).
Recupera un archivio da una vault. Questo esempio utilizza la ArchiveTransferManager classe. Per i dettagli sull'API, vedere [ArchiveTransferManager](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/Glacier/TArchiveTransferManager).
```
///
/// Download an archive from an Amazon S3 Glacier vault using the Archive
/// Transfer Manager.
///
/// The name of the vault containing the object.
/// The Id of the archive to download.
/// The local directory where the file will
/// be stored after download.
/// Async Task.
public async Task DownloadArchiveWithArchiveManagerAsync(string vaultName, string archiveId, string localFilePath)
{
try
{
var manager = new ArchiveTransferManager(_glacierService);
var options = new DownloadOptions
{
StreamTransferProgress = Progress!,
};
// Download an archive.
Console.WriteLine("Initiating the archive retrieval job and then polling SQS queue for the archive to be available.");
Console.WriteLine("When the archive is available, downloading will begin.");
await manager.DownloadAsync(vaultName, archiveId, localFilePath, options);
return true;
}
catch (AmazonGlacierException ex)
{
Console.WriteLine(ex.Message);
return false;
}
}
///
/// Event handler to track the progress of the Archive Transfer Manager.
///
/// The object that raised the event.
/// The argument values from the object that raised the
/// event.
static void Progress(object sender, StreamTransferProgressArgs args)
{
if (args.PercentDone != _currentPercentage)
{
_currentPercentage = args.PercentDone;
Console.WriteLine($"Downloaded {_currentPercentage}%");
}
}
```
+ Per i dettagli sulle API, consulta la [InitiateJob](https://docs.aws.amazon.com/goto/DotNetSDKV3/glacier-2012-06-01/InitiateJob)sezione *AWS SDK per .NET API Reference*.
------
#### [ CLI ]
**AWS CLI**
Il comando seguente avvia un processo per ottenere un inventario del vault `my-vault`.
```
aws glacier initiate-job --account-id - --vault-name my-vault --job-parameters '{"Type": "inventory-retrieval"}'
```
Output:
```
{
"location": "/0123456789012/vaults/my-vault/jobs/zbxcm3Z_3z5UkoroF7SuZKrxgGoDc3RloGduS7Eg-RO47Yc6FxsdGBgf_Q2DK5Ejh18CnTS5XW4_XqlNHS61dsO4CnMW",
"jobId": "zbxcm3Z_3z5UkoroF7SuZKrxgGoDc3RloGduS7Eg-RO47Yc6FxsdGBgf_Q2DK5Ejh18CnTS5XW4_XqlNHS61dsO4CnMW"
}
```
Amazon Glacier richiede un argomento ID account durante l'esecuzione delle operazioni, ma puoi utilizzare un trattino per specificare l'account in uso.
Il comando seguente avvia un processo per recuperare un archivio dal vault `my-vault`.
```
aws glacier initiate-job --account-id - --vault-name my-vault --job-parameters file://job-archive-retrieval.json
```
`job-archive-retrieval.json` è un file JSON nella cartella locale che specifica il tipo di processo, l’ID di archivio e alcuni parametri facoltativi:
```
{
"Type": "archive-retrieval",
"ArchiveId": "kKB7ymWJVpPSwhGP6ycSOAekp9ZYe_--zM_mw6k76ZFGEIWQX-ybtRDvc2VkPSDtfKmQrj0IRQLSGsNuDp-AJVlu2ccmDSyDUmZwKbwbpAdGATGDiB3hHO0bjbGehXTcApVud_wyDw",
"Description": "Retrieve archive on 2015-07-17",
"SNSTopic": "arn:aws:sns:us-west-2:0123456789012:my-topic"
}
```
IDs Gli archivi sono disponibili nell'output di `aws glacier upload-archive` e`aws glacier get-job-output`.
Output:
```
{
"location": "/011685312445/vaults/mwunderl/jobs/l7IL5-EkXyEY9Ws95fClzIbk2O5uLYaFdAYOi-azsX_Z8V6NH4yERHzars8wTKYQMX6nBDI9cMNHzyZJO59-8N9aHWav",
"jobId": "l7IL5-EkXy2O5uLYaFdAYOiEY9Ws95fClzIbk-azsX_Z8V6NH4yERHzars8wTKYQMX6nBDI9cMNHzyZJO59-8N9aHWav"
}
```
Per informazioni sul formato dei parametri del processo, consulta la sezione relativa all’avvio del processo nella *documentazione di riferimento dell’API Amazon Glacier*.
+ Per i dettagli sull'API, consulta [InitiateJob AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glacier/initiate-job.html)*Command Reference*.
------
#### [ Java ]
**SDK per Java 2.x**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/glacier#code-examples).
Recupera un inventario vault.
```
import software.amazon.awssdk.core.ResponseBytes;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.glacier.GlacierClient;
import software.amazon.awssdk.services.glacier.model.JobParameters;
import software.amazon.awssdk.services.glacier.model.InitiateJobResponse;
import software.amazon.awssdk.services.glacier.model.GlacierException;
import software.amazon.awssdk.services.glacier.model.InitiateJobRequest;
import software.amazon.awssdk.services.glacier.model.DescribeJobRequest;
import software.amazon.awssdk.services.glacier.model.DescribeJobResponse;
import software.amazon.awssdk.services.glacier.model.GetJobOutputRequest;
import software.amazon.awssdk.services.glacier.model.GetJobOutputResponse;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class ArchiveDownload {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
vaultName - The name of the vault.
accountId - The account ID value.
path - The path where the file is written to.
""";
if (args.length != 3) {
System.out.println(usage);
System.exit(1);
}
String vaultName = args[0];
String accountId = args[1];
String path = args[2];
GlacierClient glacier = GlacierClient.builder()
.region(Region.US_EAST_1)
.build();
String jobNum = createJob(glacier, vaultName, accountId);
checkJob(glacier, jobNum, vaultName, accountId, path);
glacier.close();
}
public static String createJob(GlacierClient glacier, String vaultName, String accountId) {
try {
JobParameters job = JobParameters.builder()
.type("inventory-retrieval")
.build();
InitiateJobRequest initJob = InitiateJobRequest.builder()
.jobParameters(job)
.accountId(accountId)
.vaultName(vaultName)
.build();
InitiateJobResponse response = glacier.initiateJob(initJob);
System.out.println("The job ID is: " + response.jobId());
System.out.println("The relative URI path of the job is: " + response.location());
return response.jobId();
} catch (GlacierException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
return "";
}
// Poll S3 Glacier = Polling a Job may take 4-6 hours according to the
// Documentation.
public static void checkJob(GlacierClient glacier, String jobId, String name, String account, String path) {
try {
boolean finished = false;
String jobStatus;
int yy = 0;
while (!finished) {
DescribeJobRequest jobRequest = DescribeJobRequest.builder()
.jobId(jobId)
.accountId(account)
.vaultName(name)
.build();
DescribeJobResponse response = glacier.describeJob(jobRequest);
jobStatus = response.statusCodeAsString();
if (jobStatus.compareTo("Succeeded") == 0)
finished = true;
else {
System.out.println(yy + " status is: " + jobStatus);
Thread.sleep(1000);
}
yy++;
}
System.out.println("Job has Succeeded");
GetJobOutputRequest jobOutputRequest = GetJobOutputRequest.builder()
.jobId(jobId)
.vaultName(name)
.accountId(account)
.build();
ResponseBytes objectBytes = glacier.getJobOutputAsBytes(jobOutputRequest);
// Write the data to a local file.
byte[] data = objectBytes.asByteArray();
File myFile = new File(path);
OutputStream os = new FileOutputStream(myFile);
os.write(data);
System.out.println("Successfully obtained bytes from a Glacier vault");
os.close();
} catch (GlacierException | InterruptedException | IOException e) {
System.out.println(e.getMessage());
System.exit(1);
}
}
}
```
+ Per i dettagli sull'API, [InitiateJob](https://docs.aws.amazon.com/goto/SdkForJavaV2/glacier-2012-06-01/InitiateJob)consulta *AWS SDK for Java 2.x API Reference*.
------
#### [ PowerShell ]
**Strumenti per PowerShell V4**
**Esempio 1: avvia un processo per recuperare un archivio dal vault specificato di proprietà dell’utente. Lo stato del processo può essere verificato utilizzando il GLCJob cmdlet Get-. Quando il processo viene completato correttamente, è possibile utilizzare il cmdlet GCJob Read-Output per recuperare il contenuto dell'archivio nel file system locale.**
```
Start-GLCJob -VaultName myvault -JobType "archive-retrieval" -JobDescription "archive retrieval" -ArchiveId "o9O9j...TX-TpIhQJw"
```
**Output:**
```
JobId JobOutputPath Location
----- ------------- --------
op1x...JSbthM /012345678912/vaults/test/jobs/op1xe...I4HqCHkSJSbthM
```
+ Per i dettagli sull'API, vedere [InitiateJob](https://docs.aws.amazon.com/powershell/v4/reference)in *AWS Strumenti per PowerShell Cmdlet* Reference (V4).
**Strumenti per V5 PowerShell **
**Esempio 1: avvia un processo per recuperare un archivio dal vault specificato di proprietà dell’utente. Lo stato del processo può essere verificato utilizzando il GLCJob cmdlet Get-. Quando il processo viene completato correttamente, è possibile utilizzare il cmdlet GCJob Read-Output per recuperare il contenuto dell'archivio nel file system locale.**
```
Start-GLCJob -VaultName myvault -JobType "archive-retrieval" -JobDescription "archive retrieval" -ArchiveId "o9O9j...TX-TpIhQJw"
```
**Output:**
```
JobId JobOutputPath Location
----- ------------- --------
op1x...JSbthM /012345678912/vaults/test/jobs/op1xe...I4HqCHkSJSbthM
```
+ Per i dettagli sull'API, vedere [InitiateJob](https://docs.aws.amazon.com/powershell/v5/reference)in *AWS Strumenti per PowerShell Cmdlet* Reference (V5).
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è altro su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/glacier#code-examples).
Recupera un inventario vault.
```
class GlacierWrapper:
"""Encapsulates Amazon S3 Glacier API operations."""
def __init__(self, glacier_resource):
"""
:param glacier_resource: A Boto3 Amazon S3 Glacier resource.
"""
self.glacier_resource = glacier_resource
@staticmethod
def initiate_inventory_retrieval(vault):
"""
Initiates an inventory retrieval job. The inventory describes the contents
of the vault. Standard retrievals typically complete within 3—5 hours.
When the job completes, you can get the inventory by calling get_output().
:param vault: The vault to inventory.
:return: The inventory retrieval job.
"""
try:
job = vault.initiate_inventory_retrieval()
logger.info("Started %s job with ID %s.", job.action, job.id)
except ClientError:
logger.exception("Couldn't start job on vault %s.", vault.name)
raise
else:
return job
```
Recupera un archivio da una vault.
```
class GlacierWrapper:
"""Encapsulates Amazon S3 Glacier API operations."""
def __init__(self, glacier_resource):
"""
:param glacier_resource: A Boto3 Amazon S3 Glacier resource.
"""
self.glacier_resource = glacier_resource
@staticmethod
def initiate_archive_retrieval(archive):
"""
Initiates an archive retrieval job. Standard retrievals typically complete
within 3—5 hours. When the job completes, you can get the archive contents
by calling get_output().
:param archive: The archive to retrieve.
:return: The archive retrieval job.
"""
try:
job = archive.initiate_archive_retrieval()
logger.info("Started %s job with ID %s.", job.action, job.id)
except ClientError:
logger.exception("Couldn't start job on archive %s.", archive.id)
raise
else:
return job
```
+ Per i dettagli sull'API, consulta [InitiateJob AWS](https://docs.aws.amazon.com/goto/boto3/glacier-2012-06-01/InitiateJob)*SDK for Python (Boto3) API Reference*.
------
# Utilizzo `ListJobs` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `ListJobs`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nei seguenti esempi di codice:
+ [Archiviazione di un file, ricezione di notifiche e avvio di processo](glacier_example_glacier_Usage_UploadNotifyInitiate_section.md)
+ [Come ottenere i contenuti dell’archivio ed eliminare l’archivio](glacier_example_glacier_Usage_RetrieveDelete_section.md)
------
#### [ .NET ]
**SDK per .NET**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Glacier#code-examples).
```
///
/// List Amazon S3 Glacier jobs.
///
/// The name of the vault to list jobs for.
/// A list of Amazon S3 Glacier jobs.
public async Task> ListJobsAsync(string vaultName)
{
var request = new ListJobsRequest
{
// Using a hyphen "-" for the Account Id will
// cause the SDK to use the Account Id associated
// with the current account.
AccountId = "-",
VaultName = vaultName,
};
var response = await _glacierService.ListJobsAsync(request);
return response.JobList;
}
```
+ Per i dettagli sull'API, [ListJobs](https://docs.aws.amazon.com/goto/DotNetSDKV3/glacier-2012-06-01/ListJobs)consulta *AWS SDK per .NET API Reference*.
------
#### [ CLI ]
**AWS CLI**
Il comando seguente elenca i lavori in corso e quelli completati di recente per un vault denominato `my-vault`:
```
aws glacier list-jobs --account-id - --vault-name my-vault
```
Output:
```
{
"JobList": [
{
"VaultARN": "arn:aws:glacier:us-west-2:0123456789012:vaults/my-vault",
"RetrievalByteRange": "0-3145727",
"SNSTopic": "arn:aws:sns:us-west-2:0123456789012:my-vault",
"Completed": false,
"SHA256TreeHash": "9628195fcdbcbbe76cdde932d4646fa7de5f219fb39823836d81f0cc0e18aa67",
"JobId": "l7IL5-EkXyEY9Ws95fClzIbk2O5uLYaFdAYOi-azsX_Z8V6NH4yERHzars8wTKYQMX6nBDI9cMNHzyZJO59-8N9aHWav",
"ArchiveId": "kKB7ymWJVpPSwhGP6ycSOAekp9ZYe_--zM_mw6k76ZFGEIWQX-ybtRDvc2VkPSDtfKmQrj0IRQLSGsNuDp-AJVlu2ccmDSyDUmZwKbwbpAdGATGDiB3hHO0bjbGehXTcApVud_wyDw",
"JobDescription": "Retrieve archive on 2015-07-17",
"ArchiveSizeInBytes": 3145728,
"Action": "ArchiveRetrieval",
"ArchiveSHA256TreeHash": "9628195fcdbcbbe76cdde932d4646fa7de5f219fb39823836d81f0cc0e18aa67",
"CreationDate": "2015-07-17T21:16:13.840Z",
"StatusCode": "InProgress"
},
{
"InventoryRetrievalParameters": {
"Format": "JSON"
},
"VaultARN": "arn:aws:glacier:us-west-2:0123456789012:vaults/my-vault",
"Completed": false,
"JobId": "zbxcm3Z_3z5UkoroF7SuZKrxgGoDc3RloGduS7Eg-RO47Yc6FxsdGBgf_Q2DK5Ejh18CnTS5XW4_XqlNHS61dsO4CnMW",
"Action": "InventoryRetrieval",
"CreationDate": "2015-07-17T20:23:41.616Z",
"StatusCode": ""InProgress""
}
]
}
```
Amazon Glacier richiede un argomento ID account durante l'esecuzione delle operazioni, ma puoi utilizzare un trattino per specificare l'account in uso.
+ Per i dettagli sull'API, consulta [ListJobs AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glacier/list-jobs.html)*Command Reference*.
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/glacier#code-examples).
```
class GlacierWrapper:
"""Encapsulates Amazon S3 Glacier API operations."""
def __init__(self, glacier_resource):
"""
:param glacier_resource: A Boto3 Amazon S3 Glacier resource.
"""
self.glacier_resource = glacier_resource
@staticmethod
def list_jobs(vault, job_type):
"""
Lists jobs by type for the specified vault.
:param vault: The vault to query.
:param job_type: The type of job to list.
:return: The list of jobs of the requested type.
"""
job_list = []
try:
if job_type == "all":
jobs = vault.jobs.all()
elif job_type == "in_progress":
jobs = vault.jobs_in_progress.all()
elif job_type == "completed":
jobs = vault.completed_jobs.all()
elif job_type == "succeeded":
jobs = vault.succeeded_jobs.all()
elif job_type == "failed":
jobs = vault.failed_jobs.all()
else:
jobs = []
logger.warning("%s isn't a type of job I can get.", job_type)
for job in jobs:
job_list.append(job)
logger.info("Got %s %s job %s.", job_type, job.action, job.id)
except ClientError:
logger.exception("Couldn't get %s jobs from %s.", job_type, vault.name)
raise
else:
return job_list
```
+ Per i dettagli sull'API, consulta [ListJobs AWS](https://docs.aws.amazon.com/goto/boto3/glacier-2012-06-01/ListJobs)*SDK for Python (Boto3) API Reference*.
------
# Utilizzo `ListTagsForVault` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `ListTagsForVault`.
------
#### [ .NET ]
**SDK per .NET**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Glacier#code-examples).
```
///
/// List tags for an Amazon S3 Glacier vault.
///
/// The name of the vault to list tags for.
/// A dictionary listing the tags attached to each object in the
/// vault and its tags.
public async Task> ListTagsForVaultAsync(string vaultName)
{
var request = new ListTagsForVaultRequest
{
// Using a hyphen "-" for the Account Id will
// cause the SDK to use the Account Id associated
// with the default user.
AccountId = "-",
VaultName = vaultName,
};
var response = await _glacierService.ListTagsForVaultAsync(request);
return response.Tags;
}
```
+ Per i dettagli sull'API, [ListTagsForVault](https://docs.aws.amazon.com/goto/DotNetSDKV3/glacier-2012-06-01/ListTagsForVault)consulta *AWS SDK per .NET API Reference*.
------
#### [ CLI ]
**AWS CLI**
Il comando seguente consente di elencare i tag applicati a un vault denominato `my-vault`:
```
aws glacier list-tags-for-vault --account-id - --vault-name my-vault
```
Output:
```
{
"Tags": {
"date": "july2015",
"id": "1234"
}
}
```
Amazon Glacier richiede un argomento ID account durante l'esecuzione delle operazioni, ma puoi utilizzare un trattino per specificare l'account in uso.
+ Per i dettagli sull'API, consulta [ListTagsForVault AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glacier/list-tags-for-vault.html)*Command Reference*.
------
# Utilizzo `ListVaults` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `ListVaults`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nel seguente esempio di codice:
+ [Archiviazione di un file, ricezione di notifiche e avvio di processo](glacier_example_glacier_Usage_UploadNotifyInitiate_section.md)
------
#### [ .NET ]
**SDK per .NET**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Glacier#code-examples).
```
///
/// List the Amazon S3 Glacier vaults associated with the current account.
///
/// A list containing information about each vault.
public async Task> ListVaultsAsync()
{
var glacierVaultPaginator = _glacierService.Paginators.ListVaults(
new ListVaultsRequest { AccountId = "-" });
var vaultList = new List();
await foreach (var vault in glacierVaultPaginator.VaultList)
{
vaultList.Add(vault);
}
return vaultList;
}
```
+ Per i dettagli sull'API, [ListVaults](https://docs.aws.amazon.com/goto/DotNetSDKV3/glacier-2012-06-01/ListVaults)consulta *AWS SDK per .NET API Reference*.
------
#### [ CLI ]
**AWS CLI**
Il comando seguente consente di elencare le vault nell’account e nella Regione predefiniti:
```
aws glacier list-vaults --account-id -
```
Output:
```
{
"VaultList": [
{
"SizeInBytes": 3178496,
"VaultARN": "arn:aws:glacier:us-west-2:0123456789012:vaults/my-vault",
"LastInventoryDate": "2015-04-07T00:26:19.028Z",
"VaultName": "my-vault",
"NumberOfArchives": 1,
"CreationDate": "2015-04-06T21:23:45.708Z"
}
]
}
```
Amazon Glacier richiede un argomento ID account durante l'esecuzione delle operazioni, ma puoi utilizzare un trattino per specificare l'account in uso.
+ Per i dettagli sull'API, consulta [ListVaults AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glacier/list-vaults.html)*Command Reference*.
------
#### [ Java ]
**SDK per Java 2.x**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/glacier#code-examples).
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.glacier.model.ListVaultsRequest;
import software.amazon.awssdk.services.glacier.model.ListVaultsResponse;
import software.amazon.awssdk.services.glacier.GlacierClient;
import software.amazon.awssdk.services.glacier.model.DescribeVaultOutput;
import software.amazon.awssdk.services.glacier.model.GlacierException;
import java.util.List;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class ListVaults {
public static void main(String[] args) {
GlacierClient glacier = GlacierClient.builder()
.region(Region.US_EAST_1)
.build();
listAllVault(glacier);
glacier.close();
}
public static void listAllVault(GlacierClient glacier) {
boolean listComplete = false;
String newMarker = null;
int totalVaults = 0;
System.out.println("Your Amazon Glacier vaults:");
try {
while (!listComplete) {
ListVaultsResponse response = null;
if (newMarker != null) {
ListVaultsRequest request = ListVaultsRequest.builder()
.marker(newMarker)
.build();
response = glacier.listVaults(request);
} else {
ListVaultsRequest request = ListVaultsRequest.builder()
.build();
response = glacier.listVaults(request);
}
List vaultList = response.vaultList();
for (DescribeVaultOutput v : vaultList) {
totalVaults += 1;
System.out.println("* " + v.vaultName());
}
// Check for further results.
newMarker = response.marker();
if (newMarker == null) {
listComplete = true;
}
}
if (totalVaults == 0) {
System.out.println("No vaults found.");
}
} catch (GlacierException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
+ Per i dettagli sull'API, [ListVaults](https://docs.aws.amazon.com/goto/SdkForJavaV2/glacier-2012-06-01/ListVaults)consulta *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/glacier#code-examples).
```
class GlacierWrapper:
"""Encapsulates Amazon S3 Glacier API operations."""
def __init__(self, glacier_resource):
"""
:param glacier_resource: A Boto3 Amazon S3 Glacier resource.
"""
self.glacier_resource = glacier_resource
def list_vaults(self):
"""
Lists vaults for the current account.
"""
try:
for vault in self.glacier_resource.vaults.all():
logger.info("Got vault %s.", vault.name)
except ClientError:
logger.exception("Couldn't list vaults.")
raise
```
+ Per i dettagli sull'API, consulta [ListVaults AWS](https://docs.aws.amazon.com/goto/boto3/glacier-2012-06-01/ListVaults)*SDK for Python (Boto3) API Reference*.
------
# Utilizzo `SetVaultNotifications` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `SetVaultNotifications`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nel seguente esempio di codice:
+ [Archiviazione di un file, ricezione di notifiche e avvio di processo](glacier_example_glacier_Usage_UploadNotifyInitiate_section.md)
------
#### [ CLI ]
**AWS CLI**
Il comando seguente configura le notifiche SNS per un vault denominato `my-vault`:
```
aws glacier set-vault-notifications --account-id - --vault-name my-vault --vault-notification-config file://notificationconfig.json
```
`notificationconfig.json` è un file JSON nella cartella corrente che specifica un argomento SNS e gli eventi da pubblicare:
```
{
"SNSTopic": "arn:aws:sns:us-west-2:0123456789012:my-vault",
"Events": ["ArchiveRetrievalCompleted", "InventoryRetrievalCompleted"]
}
```
Amazon Glacier richiede un argomento ID account durante l’esecuzione delle operazioni, ma puoi utilizzare un trattino per specificare l’account in uso.
+ Per i dettagli sull'API, consulta [SetVaultNotifications AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glacier/set-vault-notifications.html)*Command Reference.*
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/glacier#code-examples).
```
class GlacierWrapper:
"""Encapsulates Amazon S3 Glacier API operations."""
def __init__(self, glacier_resource):
"""
:param glacier_resource: A Boto3 Amazon S3 Glacier resource.
"""
self.glacier_resource = glacier_resource
def set_notifications(self, vault, sns_topic_arn):
"""
Sets an Amazon Simple Notification Service (Amazon SNS) topic as a target
for notifications. Amazon S3 Glacier publishes messages to this topic for
the configured list of events.
:param vault: The vault to set up to publish notifications.
:param sns_topic_arn: The Amazon Resource Name (ARN) of the topic that
receives notifications.
:return: Data about the new notification configuration.
"""
try:
notification = self.glacier_resource.Notification("-", vault.name)
notification.set(
vaultNotificationConfig={
"SNSTopic": sns_topic_arn,
"Events": [
"ArchiveRetrievalCompleted",
"InventoryRetrievalCompleted",
],
}
)
logger.info(
"Notifications will be sent to %s for events %s from %s.",
notification.sns_topic,
notification.events,
notification.vault_name,
)
except ClientError:
logger.exception(
"Couldn't set notifications to %s on %s.", sns_topic_arn, vault.name
)
raise
else:
return notification
```
+ Per i dettagli sull'API, consulta [SetVaultNotifications AWS](https://docs.aws.amazon.com/goto/boto3/glacier-2012-06-01/SetVaultNotifications)*SDK for Python (Boto3) API Reference*.
------
# Utilizzo `UploadArchive` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `UploadArchive`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nel seguente esempio di codice:
+ [Archiviazione di un file, ricezione di notifiche e avvio di processo](glacier_example_glacier_Usage_UploadNotifyInitiate_section.md)
------
#### [ .NET ]
**SDK per .NET**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Glacier#code-examples).
```
///
/// Upload an object to an Amazon S3 Glacier vault.
///
/// The name of the Amazon S3 Glacier vault to upload
/// the archive to.
/// The file path of the archive to upload to the vault.
/// A Boolean value indicating the success of the action.
public async Task UploadArchiveWithArchiveManager(string vaultName, string archiveFilePath)
{
try
{
var manager = new ArchiveTransferManager(_glacierService);
// Upload an archive.
var response = await manager.UploadAsync(vaultName, "upload archive test", archiveFilePath);
return response.ArchiveId;
}
catch (AmazonGlacierException ex)
{
Console.WriteLine(ex.Message);
return string.Empty;
}
}
```
+ Per i dettagli sull'API, [UploadArchive](https://docs.aws.amazon.com/goto/DotNetSDKV3/glacier-2012-06-01/UploadArchive)consulta *AWS SDK per .NET API Reference*.
------
#### [ CLI ]
**AWS CLI**
Il comando seguente carica un archivio nella cartella corrente denominata `archive.zip` in un archivio denominato `my-vault`:
```
aws glacier upload-archive --account-id - --vault-name my-vault --body archive.zip
```
Output:
```
{
"archiveId": "kKB7ymWJVpPSwhGP6ycSOAekp9ZYe_--zM_mw6k76ZFGEIWQX-ybtRDvc2VkPSDtfKmQrj0IRQLSGsNuDp-AJVlu2ccmDSyDUmZwKbwbpAdGATGDiB3hHO0bjbGehXTcApVud_wyDw",
"checksum": "969fb39823836d81f0cc028195fcdbcbbe76cdde932d4646fa7de5f21e18aa67",
"location": "/0123456789012/vaults/my-vault/archives/kKB7ymWJVpPSwhGP6ycSOAekp9ZYe_--zM_mw6k76ZFGEIWQX-ybtRDvc2VkPSDtfKmQrj0IRQLSGsNuDp-AJVlu2ccmDSyDUmZwKbwbpAdGATGDiB3hHO0bjbGehXTcApVud_wyDw"
}
```
Amazon Glacier richiede un argomento ID account durante l'esecuzione delle operazioni, ma puoi utilizzare un trattino per specificare l'account in uso.
Per recuperare un archivio caricato, avvia un processo di recupero con il comando initiate-job di aws glacier.
+ Per i dettagli sull'API, consulta [UploadArchive AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glacier/upload-archive.html)*Command Reference*.
------
#### [ Java ]
**SDK per Java 2.x**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/glacier#code-examples).
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.glacier.GlacierClient;
import software.amazon.awssdk.services.glacier.model.UploadArchiveRequest;
import software.amazon.awssdk.services.glacier.model.UploadArchiveResponse;
import software.amazon.awssdk.services.glacier.model.GlacierException;
import java.io.File;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.FileInputStream;
import java.io.IOException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class UploadArchive {
static final int ONE_MB = 1024 * 1024;
public static void main(String[] args) {
final String usage = """
Usage: \s
Where:
strPath - The path to the archive to upload (for example, C:\\AWS\\test.pdf).
vaultName - The name of the vault.
""";
if (args.length != 2) {
System.out.println(usage);
System.exit(1);
}
String strPath = args[0];
String vaultName = args[1];
File myFile = new File(strPath);
Path path = Paths.get(strPath);
GlacierClient glacier = GlacierClient.builder()
.region(Region.US_EAST_1)
.build();
String archiveId = uploadContent(glacier, path, vaultName, myFile);
System.out.println("The ID of the archived item is " + archiveId);
glacier.close();
}
public static String uploadContent(GlacierClient glacier, Path path, String vaultName, File myFile) {
// Get an SHA-256 tree hash value.
String checkVal = computeSHA256(myFile);
try {
UploadArchiveRequest uploadRequest = UploadArchiveRequest.builder()
.vaultName(vaultName)
.checksum(checkVal)
.build();
UploadArchiveResponse res = glacier.uploadArchive(uploadRequest, path);
return res.archiveId();
} catch (GlacierException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
return "";
}
private static String computeSHA256(File inputFile) {
try {
byte[] treeHash = computeSHA256TreeHash(inputFile);
System.out.printf("SHA-256 tree hash = %s\n", toHex(treeHash));
return toHex(treeHash);
} catch (IOException ioe) {
System.err.format("Exception when reading from file %s: %s", inputFile, ioe.getMessage());
System.exit(-1);
} catch (NoSuchAlgorithmException nsae) {
System.err.format("Cannot locate MessageDigest algorithm for SHA-256: %s", nsae.getMessage());
System.exit(-1);
}
return "";
}
public static byte[] computeSHA256TreeHash(File inputFile) throws IOException,
NoSuchAlgorithmException {
byte[][] chunkSHA256Hashes = getChunkSHA256Hashes(inputFile);
return computeSHA256TreeHash(chunkSHA256Hashes);
}
/**
* Computes an SHA256 checksum for each 1 MB chunk of the input file. This
* includes the checksum for the last chunk, even if it's smaller than 1 MB.
*/
public static byte[][] getChunkSHA256Hashes(File file) throws IOException,
NoSuchAlgorithmException {
MessageDigest md = MessageDigest.getInstance("SHA-256");
long numChunks = file.length() / ONE_MB;
if (file.length() % ONE_MB > 0) {
numChunks++;
}
if (numChunks == 0) {
return new byte[][] { md.digest() };
}
byte[][] chunkSHA256Hashes = new byte[(int) numChunks][];
FileInputStream fileStream = null;
try {
fileStream = new FileInputStream(file);
byte[] buff = new byte[ONE_MB];
int bytesRead;
int idx = 0;
while ((bytesRead = fileStream.read(buff, 0, ONE_MB)) > 0) {
md.reset();
md.update(buff, 0, bytesRead);
chunkSHA256Hashes[idx++] = md.digest();
}
return chunkSHA256Hashes;
} finally {
if (fileStream != null) {
try {
fileStream.close();
} catch (IOException ioe) {
System.err.printf("Exception while closing %s.\n %s", file.getName(),
ioe.getMessage());
}
}
}
}
/**
* Computes the SHA-256 tree hash for the passed array of 1 MB chunk
* checksums.
*/
public static byte[] computeSHA256TreeHash(byte[][] chunkSHA256Hashes)
throws NoSuchAlgorithmException {
MessageDigest md = MessageDigest.getInstance("SHA-256");
byte[][] prevLvlHashes = chunkSHA256Hashes;
while (prevLvlHashes.length > 1) {
int len = prevLvlHashes.length / 2;
if (prevLvlHashes.length % 2 != 0) {
len++;
}
byte[][] currLvlHashes = new byte[len][];
int j = 0;
for (int i = 0; i < prevLvlHashes.length; i = i + 2, j++) {
// If there are at least two elements remaining.
if (prevLvlHashes.length - i > 1) {
// Calculate a digest of the concatenated nodes.
md.reset();
md.update(prevLvlHashes[i]);
md.update(prevLvlHashes[i + 1]);
currLvlHashes[j] = md.digest();
} else { // Take care of the remaining odd chunk
currLvlHashes[j] = prevLvlHashes[i];
}
}
prevLvlHashes = currLvlHashes;
}
return prevLvlHashes[0];
}
/**
* Returns the hexadecimal representation of the input byte array
*/
public static String toHex(byte[] data) {
StringBuilder sb = new StringBuilder(data.length * 2);
for (byte datum : data) {
String hex = Integer.toHexString(datum & 0xFF);
if (hex.length() == 1) {
// Append leading zero.
sb.append("0");
}
sb.append(hex);
}
return sb.toString().toLowerCase();
}
}
```
+ Per i dettagli sull'API, [UploadArchive](https://docs.aws.amazon.com/goto/SdkForJavaV2/glacier-2012-06-01/UploadArchive)consulta *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK per JavaScript (v3)**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/glacier#code-examples).
Crea il client.
```
const { GlacierClient } = require("@aws-sdk/client-glacier");
// Set the AWS Region.
const REGION = "REGION";
//Set the Redshift Service Object
const glacierClient = new GlacierClient({ region: REGION });
export { glacierClient };
```
Caricamento dell’archivio.
```
// Load the SDK for JavaScript
import { UploadArchiveCommand } from "@aws-sdk/client-glacier";
import { glacierClient } from "./libs/glacierClient.js";
// Set the parameters
const vaultname = "VAULT_NAME"; // VAULT_NAME
// Create a new service object and buffer
const buffer = new Buffer.alloc(2.5 * 1024 * 1024); // 2.5MB buffer
const params = { vaultName: vaultname, body: buffer };
const run = async () => {
try {
const data = await glacierClient.send(new UploadArchiveCommand(params));
console.log("Archive ID", data.archiveId);
return data; // For unit tests.
} catch (err) {
console.log("Error uploading archive!", err);
}
};
run();
```
+ Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS SDK per JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/glacier-example-uploadarchive.html).
+ Per i dettagli sull'API, [UploadArchive](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/glacier/command/UploadArchiveCommand)consulta *AWS SDK per JavaScript API Reference*.
**SDK per JavaScript (v2)**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascript/example_code/glacier#code-examples).
```
// Load the SDK for JavaScript
var AWS = require("aws-sdk");
// Set the region
AWS.config.update({ region: "REGION" });
// Create a new service object and buffer
var glacier = new AWS.Glacier({ apiVersion: "2012-06-01" });
buffer = Buffer.alloc(2.5 * 1024 * 1024); // 2.5MB buffer
var params = { vaultName: "YOUR_VAULT_NAME", body: buffer };
// Call Glacier to upload the archive.
glacier.uploadArchive(params, function (err, data) {
if (err) {
console.log("Error uploading archive!", err);
} else {
console.log("Archive ID", data.archiveId);
}
});
```
+ Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS SDK per JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/glacier-example-uploadrchive.html).
+ Per i dettagli sull'API, [UploadArchive](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/glacier-2012-06-01/UploadArchive)consulta *AWS SDK per JavaScript API Reference*.
------
#### [ PowerShell ]
**Strumenti per PowerShell V4**
**Esempio 1: carica un unico file nell’archivio specificato, restituendo l’ID dell’archivio e il checksum calcolato.**
```
Write-GLCArchive -VaultName myvault -FilePath c:\temp\blue.bin
```
**Output:**
```
FilePath ArchiveId Checksum
-------- --------- --------
C:\temp\blue.bin o9O9jUUs...TTX-TpIhQJw 79f3e...f4395b
```
**Esempio 2: carica il contenuto di una gerarchia di cartelle nel vault specificato nell’account dell’utente. Per ogni file caricato, il cmdlet genera il nome di file, l’ID di archivio corrispondente e il checksum calcolato dell’archivio.**
```
Write-GLCArchive -VaultName myvault -FolderPath . -Recurse
```
**Output:**
```
FilePath ArchiveId Checksum
-------- --------- --------
C:\temp\blue.bin o9O9jUUs...TTX-TpIhQJw 79f3e...f4395b
C:\temp\green.bin qXAfOdSG...czo729UHXrw d50a1...9184b9
C:\temp\lum.bin 39aNifP3...q9nb8nZkFIg 28886...5c3e27
C:\temp\red.bin vp7E6rU_...Ejk_HhjAxKA e05f7...4e34f5
C:\temp\Folder1\file1.txt _eRINlip...5Sxy7dD2BaA d0d2a...c8a3ba
C:\temp\Folder2\file2.iso -Ix3jlmu...iXiDh-XfOPA 7469e...3e86f1
```
+ Per i dettagli sull'API, vedere [UploadArchive](https://docs.aws.amazon.com/powershell/v4/reference)in *AWS Strumenti per PowerShell Cmdlet Reference (*V4).
**Strumenti per V5 PowerShell **
**Esempio 1: carica un unico file nell’archivio specificato, restituendo l’ID dell’archivio e il checksum calcolato.**
```
Write-GLCArchive -VaultName myvault -FilePath c:\temp\blue.bin
```
**Output:**
```
FilePath ArchiveId Checksum
-------- --------- --------
C:\temp\blue.bin o9O9jUUs...TTX-TpIhQJw 79f3e...f4395b
```
**Esempio 2: carica il contenuto di una gerarchia di cartelle nel vault specificato nell’account dell’utente. Per ogni file caricato, il cmdlet genera il nome di file, l’ID di archivio corrispondente e il checksum calcolato dell’archivio.**
```
Write-GLCArchive -VaultName myvault -FolderPath . -Recurse
```
**Output:**
```
FilePath ArchiveId Checksum
-------- --------- --------
C:\temp\blue.bin o9O9jUUs...TTX-TpIhQJw 79f3e...f4395b
C:\temp\green.bin qXAfOdSG...czo729UHXrw d50a1...9184b9
C:\temp\lum.bin 39aNifP3...q9nb8nZkFIg 28886...5c3e27
C:\temp\red.bin vp7E6rU_...Ejk_HhjAxKA e05f7...4e34f5
C:\temp\Folder1\file1.txt _eRINlip...5Sxy7dD2BaA d0d2a...c8a3ba
C:\temp\Folder2\file2.iso -Ix3jlmu...iXiDh-XfOPA 7469e...3e86f1
```
+ Per i dettagli sull'API, vedere [UploadArchive](https://docs.aws.amazon.com/powershell/v5/reference)in *AWS Strumenti per PowerShell Cmdlet Reference (*V5).
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è altro su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/glacier#code-examples).
```
class GlacierWrapper:
"""Encapsulates Amazon S3 Glacier API operations."""
def __init__(self, glacier_resource):
"""
:param glacier_resource: A Boto3 Amazon S3 Glacier resource.
"""
self.glacier_resource = glacier_resource
@staticmethod
def upload_archive(vault, archive_description, archive_file):
"""
Uploads an archive to a vault.
:param vault: The vault where the archive is put.
:param archive_description: A description of the archive.
:param archive_file: The archive file to put in the vault.
:return: The uploaded archive.
"""
try:
archive = vault.upload_archive(
archiveDescription=archive_description, body=archive_file
)
logger.info(
"Uploaded %s with ID %s to vault %s.",
archive_description,
archive.id,
vault.name,
)
except ClientError:
logger.exception(
"Couldn't upload %s to %s.", archive_description, vault.name
)
raise
else:
return archive
```
+ Per i dettagli sull'API, consulta [UploadArchive AWS](https://docs.aws.amazon.com/goto/boto3/glacier-2012-06-01/UploadArchive)*SDK for Python (Boto3) API Reference*.
------
# Utilizzo `UploadMultipartPart` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `UploadMultipartPart`.
------
#### [ CLI ]
**AWS CLI**
Il comando seguente carica la prima parte da 1 MiB (1024 x 1024 byte) di un archivio:
```
aws glacier upload-multipart-part --body part1 --range 'bytes 0-1048575/*' --account-id - --vault-name my-vault --upload-id 19gaRezEXAMPLES6Ry5YYdqthHOC_kGRCT03L9yetr220UmPtBYKk-OssZtLqyFu7sY1_lR7vgFuJV6NtcV5zpsJ
```
Amazon Glacier richiede un argomento ID account durante l'esecuzione delle operazioni, ma puoi utilizzare un trattino per specificare l'account in uso.
Il parametro body indica il percorso di un file delle parti sul filesystem locale. Il parametro range utilizza un intervallo di contenuti HTTP che indica i byte occupati dalla parte nell’archivio completato. L’ID di caricamento viene restituito dal comando `aws glacier initiate-multipart-upload` e può essere ottenuto anche utilizzando `aws glacier list-multipart-uploads`.
*Per ulteriori informazioni sui caricamenti multiparte su Amazon Glacier tramite l'interfaccia a riga di comando, consulta Using Amazon Glacier AWS nella CLI User Guide.AWS *
+ *Per i dettagli sull'API, consulta Command Reference. [UploadMultipartPart](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glacier/upload-multipart-part.html)AWS CLI *
------
#### [ JavaScript ]
**SDK per JavaScript (v2)**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascript/example_code/glacier#code-examples).
Creazione di un caricamento in più parti di blocchi da 1 megabyte di un oggetto Buffer.
```
// Create a new service object and some supporting variables
var glacier = new AWS.Glacier({ apiVersion: "2012-06-01" }),
vaultName = "YOUR_VAULT_NAME",
buffer = new Buffer(2.5 * 1024 * 1024), // 2.5MB buffer
partSize = 1024 * 1024, // 1MB chunks,
numPartsLeft = Math.ceil(buffer.length / partSize),
startTime = new Date(),
params = { vaultName: vaultName, partSize: partSize.toString() };
// Compute the complete SHA-256 tree hash so we can pass it
// to completeMultipartUpload request at the end
var treeHash = glacier.computeChecksums(buffer).treeHash;
// Initiate the multipart upload
console.log("Initiating upload to", vaultName);
// Call Glacier to initiate the upload.
glacier.initiateMultipartUpload(params, function (mpErr, multipart) {
if (mpErr) {
console.log("Error!", mpErr.stack);
return;
}
console.log("Got upload ID", multipart.uploadId);
// Grab each partSize chunk and upload it as a part
for (var i = 0; i < buffer.length; i += partSize) {
var end = Math.min(i + partSize, buffer.length),
partParams = {
vaultName: vaultName,
uploadId: multipart.uploadId,
range: "bytes " + i + "-" + (end - 1) + "/*",
body: buffer.slice(i, end),
};
// Send a single part
console.log("Uploading part", i, "=", partParams.range);
glacier.uploadMultipartPart(partParams, function (multiErr, mData) {
if (multiErr) return;
console.log("Completed part", this.request.params.range);
if (--numPartsLeft > 0) return; // complete only when all parts uploaded
var doneParams = {
vaultName: vaultName,
uploadId: multipart.uploadId,
archiveSize: buffer.length.toString(),
checksum: treeHash, // the computed tree hash
};
console.log("Completing upload...");
glacier.completeMultipartUpload(doneParams, function (err, data) {
if (err) {
console.log("An error occurred while uploading the archive");
console.log(err);
} else {
var delta = (new Date() - startTime) / 1000;
console.log("Completed upload in", delta, "seconds");
console.log("Archive ID:", data.archiveId);
console.log("Checksum: ", data.checksum);
}
});
});
}
});
```
+ Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS SDK per JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/glacier-example-multipart-upload.html).
+ Per i dettagli sull'API, [UploadMultipartPart](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/glacier-2012-06-01/UploadMultipartPart)consulta *AWS SDK per JavaScript API Reference*.
------