

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Utilizzo dello storage compatibile con Amazon S3 su Snowball Edge con un cluster di dispositivi Snow
<a name="ClusterOverview"></a>

Un cluster è una raccolta di tre o più dispositivi Snowball Edge utilizzati come singola unità logica per scopi di archiviazione e calcolo locali. Un cluster offre due vantaggi principali rispetto a un dispositivo Snowball Edge autonomo per l'archiviazione e l'elaborazione locali:
+ **Maggiore durabilità**: i dati S3 archiviati in un cluster di dispositivi Snowball Edge godono di una maggiore durabilità dei dati rispetto a un singolo dispositivo. Inoltre, i dati sul cluster rimangono sicuri e utilizzabili, nonostante le possibili interruzioni hardware che interessano il cluster. I cluster sono in grado di sopportare la perdita di un dispositivo in cluster da 3 e 4 dispositivi e fino a due dispositivi in cluster da 5 a 16 dispositivi prima che i dati siano in pericolo. È possibile sostituire i nodi non integri per mantenere la durabilità e la sicurezza dei dati archiviati nel cluster.
+ **Maggiore storage**: con i dispositivi ottimizzati per lo storage Snowball Edge, puoi creare un singolo cluster a 16 nodi con un massimo di 2,6 PB di capacità di storage utilizzabile compatibile con S3. Con i dispositivi ottimizzati per l'elaborazione Snowball Edge, puoi creare un singolo cluster a 16 nodi con un massimo di 501 TB di capacità di storage utilizzabile compatibile con S3.

Un cluster di dispositivi Snowball Edge è composto da nodi senza leader. Qualsiasi nodo può scrivere e leggere dati dall'intero cluster e tutti i nodi sono in grado di eseguire la behind-the-scenes gestione del cluster.

Tieni a mente le seguenti considerazioni quando pianifichi di utilizzare un cluster di dispositivi Snowball Edge:
+ Si consiglia di fornire una fonte di alimentazione ridondante per tutti i dispositivi del cluster per ridurre i potenziali problemi di prestazioni e stabilità del cluster.
+ Come per i processi di elaborazione e archiviazione locali autonomi, i dati archiviati in un cluster non possono essere importati in Amazon S3 senza ordinare dispositivi aggiuntivi come parte di processi di importazione separati. Se ordini dispositivi aggiuntivi come processi di importazione, puoi trasferire i dati dal cluster ai dispositivi di importazione. 
+ Per trasferire dati in un cluster da Amazon S3, utilizza l'API Amazon S3 per creare bucket Amazon S3 sul cluster per archiviare e recuperare oggetti da S3. Inoltre, puoi utilizzare AWS DataSync per trasferire oggetti tra i servizi di storage e AWS lo storage compatibile con Amazon S3 su Snowball Edge su un dispositivo Snowball Edge. Per ulteriori informazioni, consulta [Configurazione dei trasferimenti con storage compatibile con S3 su Snowball](https://docs.aws.amazon.com/datasync/latest/userguide/s3-compatible-storage-snow.html) Edge.
+ Puoi creare un lavoro per ordinare un cluster di dispositivi da, da Console di gestione della famiglia di servizi AWS Snow AWS CLI, o da uno dei. AWS SDKs Per ulteriori informazioni, consulta [Guida introduttiva a Snowball Edge](getting-started.md).
+ Ogni dispositivo del cluster ha un ID di nodo. Un *ID di nodo* è un identificatore univoco per ogni dispositivo del cluster, come un ID di lavoro per un dispositivo autonomo. Puoi ottenere il nodo IDs dal Console di gestione della famiglia di servizi AWS Snow, dal AWS CLI AWS SDKs, e dal client Snowball Edge. Il client Snowball Edge comanda `describe-device` e `describe-cluster` restituisce il nodo IDs con altre informazioni sui dispositivi o sul cluster.
+ La durata di un cluster è limitata dal certificato di sicurezza concesso ai dispositivi del cluster quando viene effettuato il provisioning del cluster. Per impostazione predefinita, i dispositivi Snowball Edge possono essere utilizzati per un massimo di 360 giorni prima di dover essere restituiti. Al termine di tale periodo, i dispositivi smettono di rispondere alle read/write richieste. Se devi conservare uno o più dispositivi per più di 360 giorni, contatta Supporto AWS.
+ Quando AWS riceve un dispositivo restituito che faceva parte di un cluster, eseguiamo una cancellazione completa del dispositivo. Questa cancellazione rispetta gli standard 800-88 della National Institute of Standards and Technology (NIST).<a name="cluster-table"></a>


**Storage compatibile con Amazon S3 su cluster Snowball Edge, tolleranza agli errori e capacità di storage**  

| Dimensione del cluster | Tolleranza ai guasti | Capacità di storage dei dispositivi Snowball Edge Compute Optimized (elaborazione ottimizzata con AMD EPYC NVMe Gen2 e) (in TB) | Capacità di storage dei dispositivi da 210 TB ottimizzati per lo storage Snowball Edge (in TB) | 
| --- | --- | --- | --- | 
|  3  |  Perdita di un massimo di 1 nodo  |  38  |  438  | 
|  4  |  Perdita di un massimo di 1 nodo  |  57  |  657  | 
|  5  |  Perdita di un massimo di 2 nodi  |  57  |  657  | 
|  6  |  Perdita di un massimo di 2 nodi  |  76  |  904  | 
|  7  |  Perdita di un massimo di 2 nodi  |  95  |  1096  | 
|  8  |  Perdita di un massimo di 2 nodi  |  114  |  1315  | 
|  9  |  Perdita di un massimo di 2 nodi  |  133  |  1534  | 
|  10  |  Perdita di un massimo di 2 nodi  |  152  |  1754  | 
|  11  |  Perdita di un massimo di 2 nodi  |  165  |  1970  | 
|  12  |  Perdita di un massimo di 2 nodi  |  171  |  1973  | 
|  13  |  Perdita di un massimo di 2 nodi  |  190  |  2192  | 
|  14  |  Perdita di un massimo di 2 nodi  |  209  |  2411  | 
|  15  |  Perdita di un massimo di 2 nodi  |  225  |  2625  | 
|  16  |  Perdita di un massimo di 2 nodi  |  228  |  2631  | 

Dopo aver sbloccato un cluster, sei pronto per archiviare e accedere ai dati su quel cluster. Puoi utilizzare l'endpoint compatibile con Amazon S3 per leggere e scrivere dati su un cluster.

Per leggere o scrivere dati su un cluster, devi avere un read/write quorum che non superi il numero consentito di nodi non disponibili nel cluster di dispositivi.

## Quorum del cluster Snowball Edge
<a name="clusterquorums"></a>

Un *quorum* rappresenta il numero minimo di dispositivi Snowball Edge in un cluster che devono comunicare tra loro per mantenere un quorum. read/write 

*Quando tutti i dispositivi di un cluster sono integri, si dispone di un quorum di lettura/scrittura per il cluster.* Se uno o due di questi dispositivi vanno offline, si riduce la capacità operativa del cluster. Tuttavia, puoi ancora eseguire operazioni di lettura e scrittura nel cluster. Con tutti i dispositivi operativi tranne uno o due, il cluster ha ancora un read/write quorum. Il numero di nodi che possono andare offline prima che la capacità operativa del cluster venga compromessa è indicato in. [this table](#cluster-table)

Quorom può andare perso se un cluster perde più del numero di dispositivi indicato in. [this table](#cluster-table) Quando si perde un quorom, il cluster è offline e i dati in esso contenuti non sono disponibili. A seconda della gravità dell'evento, potresti riuscire a risolvere questo problema o perdere definitivamente i dati. Se si tratta di un evento di alimentazione esterno temporaneo ed è possibile riaccendere i dispositivi Snowball Edge e sbloccare tutti i nodi del cluster, i dati sono nuovamente disponibili.

**Importante**  
Se non esiste un quorum minimo di nodi integri, contatta. Supporto AWS

È possibile utilizzare il `describe-cluster` comando per visualizzare lo stato di blocco e la raggiungibilità della rete di ciascun nodo. Garantire che i dispositivi del cluster siano integri e connessi è una responsabilità amministrativa che ti assumi quando utilizzi lo storage del cluster. Per ulteriori informazioni, consulta [Rilevare lo stato del dispositivo](https://docs.aws.amazon.com/snowball/latest/developer-guide/using-client-commands.html#client-status).

Se ritieni che uno o più nodi non siano integri, puoi sostituire i nodi del cluster per mantenere il quorom e l'integrità e la stabilità dei dati. Per ulteriori informazioni, consulta [Sostituzione di un nodo in un cluster](replacement.md).

# Riconnessione di un nodo del cluster non disponibile
<a name="reconnectingclusternodefortpoint"></a>

Un *nodo* o un dispositivo all'interno di un cluster può diventare temporaneamente non disponibile a causa di un problema come l'interruzione dell'alimentazione o della rete senza danneggiare i dati sul nodo. Quando si verifica, ciò questo influenza lo stato del cluster. La raggiungibilità della rete e lo stato di blocco di un nodo vengono segnalati nel client Snowball Edge utilizzando `snowballEdge describe-cluster` il comando.

Ti consigliamo di posizionare fisicamente il cluster in modo da accedere alla parte anteriore, posteriore e superiore di tutti i nodi. In questo modo, puoi accedere ai cavi di alimentazione e di rete sul retro, alle etichette di spedizione sulla parte superiore per il nodo IDs e agli schermi LCD sulla parte anteriore dei dispositivi per gli indirizzi IP e altre informazioni amministrative.

Quando rilevi che un nodo non è disponibile, ti consigliamo di provare una delle seguenti procedure, a seconda dello scenario che ha causato la mancata disponibilità del nodo.

**Per ristabilire la connessione a un nodo non disponibile**

1. Assicurati che il nodo sia acceso.

1. Assicurati che il nodo sia connesso alla stessa rete interna a cui è connesso il resto del cluster.

1. Se devi accendere il nodo, attendi fino a 20 minuti che finisca.

1. Esegui il `snowballEdge unlock-cluster` comando o il `snowballEdge associate-device` comando. Per un esempio, consulta [Sblocco dei dispositivi Snowball](https://docs.aws.amazon.com/snowball/latest/developer-guide/using-client-commands.html#setting-up-client) Edge.

**Per ricollegare un nodo non disponibile che ha perso la connettività di rete ma non l'alimentazione**

1. Verificare che il nodo sia connesso alla stessa rete interna su cui si trova il resto del cluster.

1. Eseguire il comando `snowballEdge describe-device` per vedere quando il nodo precedentemente non disponibile viene nuovamente aggiunto al cluster. Per un esempio, vedi [Ottenere lo stato del dispositivo](https://docs.aws.amazon.com/snowball/latest/developer-guide/using-client-commands.html#client-status).

Dopo aver eseguito le procedure precedenti, i nodi dovrebbero funzionare normalmente. È inoltre necessario avere un read/write quorum. In caso contrario, uno o più nodi potrebbero presentare un problema più grave e potrebbe essere necessario rimuoverli dal cluster.

# Sostituzione di un nodo in un cluster
<a name="replacement"></a>

Per sostituire un nodo, devi prima ordinarne uno sostitutivo. È possibile ordinare un nodo sostitutivo dalla console, da AWS CLI, o da uno dei AWS SDKs. Se stai ordinando un nodo sostitutivo dalla console, puoi ordinare ricambi per qualsiasi processo che non è stato annullato o completato. Quindi, dissociate il nodo non integro dal cluster, connettete il nodo sostitutivo alla rete e sbloccate il cluster, incluso il nodo sostitutivo, associate il nodo sostitutivo al cluster e riavviate lo storage compatibile con Amazon S3 sul servizio Snowball Edge.

**Per ordinare un nodo sostitutivo dalla console**

1. Accedi alla [Console di gestione della famiglia di servizi AWS Snow](https://console.aws.amazon.com/snowfamily/home).

1. Individuare e scegliere un processo per un nodo che appartiene al cluster creato dal pannello di controllo del processo.

1. Per **Actions (Operazioni)**, selezionare **Replace node (Sostituisci nodo)**.

   In questo modo viene aperta la fase finale della creazione guidata processo, in cui tutte le impostazioni sono identiche alla modalità di creazione originale del cluster.

1. Scegli **Crea processo**.

Lo Snowball Edge sostitutivo è ora in arrivo. Utilizzare la procedura seguente per rimuovere il nodo non integro dal cluster.

**Per rimuovere un nodo da un cluster**

1. Spegnere il nodo da rimuovere. Per ulteriori informazioni, consulta [Powering off the Snowball](https://docs.aws.amazon.com/snowball/latest/developer-guide/turnitoff.html) Edge.

1. Usa il `describe-cluster` comando per assicurarti che il nodo non integro sia irraggiungibile. Ciò è indicato dal valore di `UNREACHABLE` per il `State` nome dell'oggetto. `NetworkReachability`

   ```
   snowballEdge describe-cluster --manifest-file path/to/manifest/file.bin --unlock-code unlock-code --endpoint https://ip-address-of-device-in-cluster                
   ```  
**Example dell'`describe-cluster`output**  

   ```
   {
       "ClusterId": "CID12345678-1234-1234-1234-123456789012",
       "Devices": [
           {
               "DeviceId": "JID12345678-1234-1234-1234-123456789012",
               "UnlockStatus": {
                   "State": "UNLOCKED"
               },
               "ActiveNetworkInterface": {
                   "IpAddress": "10.0.0.0"
               },
               "ClusterAssociation": {
                   "ClusterId": "CID12345678-1234-1234-1234-123456789012",
                   "State": "ASSOCIATED"
               },
               "NetworkReachability": {
                   "State": "REACHABLE"
               },
               "Tags": []
           },
           {
               "DeviceId": "JID12345678-1234-1234-1234-123456789013",
               "UnlockStatus": {
                   "State": "UNLOCKED"
               },
               "ActiveNetworkInterface": {
                   "IpAddress": "10.0.0.1"
               },
               "ClusterAssociation": {
                   "ClusterId": "CID12345678-1234-1234-1234-123456789012",
                   "State": "ASSOCIATED"
               },
               "NetworkReachability": {
                   "State": "REACHABLE"
               },
               "Tags": []
           },
           {
               "DeviceId": "JID12345678-1234-1234-1234-123456789014",
               "ClusterAssociation": {
                   "ClusterId": "CID12345678-1234-1234-1234-123456789012",
                   "State": "ASSOCIATED"
               },
               "NetworkReachability": {
                   "State": "UNREACHABLE"
               }
           }
       ]
   }
   ```

1. Usa il `describe-service` comando per assicurarti che lo stato del `s3-snow` servizio sia`DEGRADED`.

   ```
   snowballEdge describe-service --service-id s3-snow --device-ip-addresses snow-device-1-address snow-device-2-address --manifest-file path/to/manifest/file.bin --unlock-code unlock-code --endpoint https://snow-device-ip-address        
   ```  
**Example dell'output del `describe-service` comando**  

   ```
   {
       "ServiceId": "s3-snow",
       "Autostart": true,
       "Status": {
           "State": "DEGRADED"
       },
       "ServiceCapacities": [
           {
               "Name": "S3 Storage",
               "Unit": "Byte",
               "Used": 38768180432,
               "Available": 82961231819568
           }
       ],
       "Endpoints": [
           {
               "Protocol": "https",
               "Port": 443,
               "Host": "10.0.0.10",
               "CertificateAssociation": {
                   "CertificateArn": "arn:aws:snowball-device:::certificate/7Rg2lP9tQaHnW4sC6xUzF1vGyD3jB5kN8MwEiYpT"
               },
               "Description" : "s3-snow bucket API endpoint (for s3control SDK)",
               "DeviceId": "JID-beta-207012320001-24-02-05-17-17-26",
               "Status": {
                   "State": "ACTIVE"
               }
           },
           {
               "Protocol": "https",
               "Port": 443,
               "Host": "10.0.0.11",
               "CertificateAssociation": {
                   "CertificateArn": "arn:aws:snowball-device:::certificate/7Rg2lP9tQaHnW4sC6xUzF1vGyD3jB5kN8MwEiYpT"
               },
               "Description": "Description" : "s3-snow object & bucket API endpoint (for s3api SDK)",
               "DeviceId": "JID-beta-207012320001-24-02-05-17-17-26",
               "Status": {
                   "State": "ACTIVE"
               }
           },
           {
               "Protocol": "https",
               "Port": 443,
               "Host": "10.0.0.12",
               "CertificateAssociation": {
                   "CertificateArn": "arn:aws:snowball-device:::certificate/7Rg2lP9tQaHnW4sC6xUzF1vGyD3jB5kN8MwEiYpT"
               },
               "Description": "Description" : "s3-snow bucket API endpoint (for s3control SDK)",
               "DeviceId": "JID-beta-207012240003-24-02-05-17-17-27",
               "Status": {
                   "State": "ACTIVE"
               }
           },
           {
               "Protocol": "https",
               "Port": 443,
               "Host": "10.0.0.13",
               "CertificateAssociation": {
                   "CertificateArn": "arn:aws:snowball-device:::certificate/7Rg2lP9tQaHnW4sC6xUzF1vGyD3jB5kN8MwEiYpT"
               },
               "Description": "Description" : "s3-snow object & bucket API endpoint (for s3api SDK)",
               "DeviceId": "JID-beta-207012320001-24-02-05-17-17-27",
               "Status": {
                   "State": "ACTIVE"
               }
           }
       ]
   }
   ```

1. Usa il `disassociate-device` comando per dissociare e rimuovere il nodo non integro dal cluster.

   ```
   snowballEdge disassociate-device --device-id device-id --manifest-file path/to/manifest/file.bin --unlock-code unlock-code --endpoint https://ip-address-of-unhealthy-device                    
   ```  
**Example output del comando `disassociate-device`**  

   ```
   Disassociating your Snowball Edge device from the cluster. Your Snowball Edge device will be disassociated from the cluster when it is in the "DISASSOCIATED" state. You can use the describe-cluster command to determine the state of your cluster.                        
   ```

1. Usa nuovamente il `describe-cluster` comando per assicurarti che il nodo non integro venga dissociato dal cluster.

   ```
   snowballEdge describe-cluster --manifest-file path/to/manifest/file.bin --unlock-code unlock-code --endpoint https:ip-address-of-healthy-device                    
   ```  
**Example del `describe-cluster` comando che mostra il nodo è dissociato**  

   ```
   {
       "ClusterId": "CID12345678-1234-1234-1234-123456789012",
       "Devices": [
           {
               "DeviceId": "JID12345678-1234-1234-1234-123456789012",
               "UnlockStatus": {
                   "State": "UNLOCKED"
               },
               "ActiveNetworkInterface": {
                   "IpAddress": "10.0.0.0"
               },
               "ClusterAssociation": {
                   "ClusterId": "CID12345678-1234-1234-1234-123456789012",
                   "State": "ASSOCIATED"
               },
               "NetworkReachability": {
                   "State": "REACHABLE"
               },
               "Tags": []
           },
           {
               "DeviceId": "JID12345678-1234-1234-1234-123456789013",
               "UnlockStatus": {
                   "State": "UNLOCKED"
               },
               "ActiveNetworkInterface": {
                   "IpAddress": "10.0.0.1"
               },
               "ClusterAssociation": {
                   "ClusterId": "CID12345678-1234-1234-1234-123456789012",
                   "State": "ASSOCIATED"
               },
               "NetworkReachability": {
                   "State": "REACHABLE"
               },
               "Tags": []
           },
           {
               "DeviceId": "JID12345678-1234-1234-1234-123456789014",
               "ClusterAssociation": {
                   "ClusterId": "CID12345678-1234-1234-1234-123456789012",
                   "State": "DISASSOCIATED"
               }
           }
       ]
   }
   ```

1. Spegnere e riportare il dispositivo non integro a. AWS Per ulteriori informazioni, vedere [Spegnimento del dispositivo Snowball Edge e Restituzione](https://docs.aws.amazon.com/snowball/latest/developer-guide/turnitoff.html) [del dispositivo Snowball](https://docs.aws.amazon.com/snowball/latest/developer-guide/return-device.html) Edge.

Quando arriva il dispositivo sostitutivo, utilizza la procedura seguente per aggiungerlo al cluster.

**Per aggiungere un dispositivo sostitutivo**

1. Posiziona il dispositivo sostitutivo per il cluster in modo da avere accesso alla parte anteriore, posteriore e superiore di tutti i dispositivi.

1. Accendi il nodo e assicurati che sia connesso alla stessa rete interna del resto del cluster. Per ulteriori informazioni, consulta [Connessione alla rete locale](https://docs.aws.amazon.com/snowball/latest/developer-guide/getting-started-connect.html).

1. Usa il `unlock-cluster` comando e includi l'indirizzo IP del nuovo nodo.

   ```
   snowballEdge unlock-cluster --manifest-file path/to/manifest/file.bin --unlock-code unlock-code --endpoint https://ip-address-of-cluster-device --device-ip-addresses node-1-ip-address node-2-ip-address new-node-ip-address    
   ```

   Lo stato del nuovo nodo rimarrà `DEGRADED` invariato finché non lo assocerai al cluster nel passaggio successivo.

1. Usa il `associate-device` comando per associare il nodo sostitutivo al cluster.

   ```
   snowballEdge associate-device --device-ip-address new-node-ip-address
   ```  
**Example dell'output del `associate-device` comando**  

   ```
   Associating your Snowball Edge device with the cluster. Your Snowball Edge device will be associated with the cluster when it is in the ASSOCIATED state. You can use the describe-device command to determine the state of your devices.                        
   ```

1. Usa il `describe-cluster` comando per assicurarti che il nuovo nodo sia associato al cluster.

   ```
   snowballEdge describe-cluster --manifest-file path/to/manifest/file.bin --unlock-code unlock-code --endpoint https://node-ip-address                    
   ```  
**Example dell'output del `describe-cluster` comando**  

   ```
   {
       "ClusterId": "CID12345678-1234-1234-1234-123456789012",
       "Devices": [
           {
               "DeviceId": "JID12345678-1234-1234-1234-123456789012",
               "UnlockStatus": {
                   "State": "UNLOCKED"
               },
               "ActiveNetworkInterface": {
                   "IpAddress": "10.0.0.0"
               },
               "ClusterAssociation": {
                   "ClusterId": "CID12345678-1234-1234-1234-123456789012",
                   "State": "ASSOCIATED"
               },
               "NetworkReachability": {
                   "State": "REACHABLE"
               },
               "Tags": []
           },
           {
               "DeviceId": "JID-CID12345678-1234-1234-1234-123456789013",
               "UnlockStatus": {
                   "State": "UNLOCKED"
               },
               "ActiveNetworkInterface": {
                   "IpAddress": "10.0.0.1"
               },
               "ClusterAssociation": {
                   "ClusterId": "CID12345678-1234-1234-1234-123456789012",
                   "State": "ASSOCIATED"
               },
               "NetworkReachability": {
                   "State": "REACHABLE"
               },
               "Tags": []
           },
           {
               "DeviceId": "JID-CID12345678-1234-1234-1234-123456789015",
               "UnlockStatus": {
                   "State": "UNLOCKED"
               },
               "ActiveNetworkInterface": {
                   "IpAddress": "10.0.0.2"
               },
               "ClusterAssociation": {
                   "ClusterId": "CID12345678-1234-1234-1234-123456789012",
                   "State": "ASSOCIATED"
               },
               "NetworkReachability": {
                   "State": "REACHABLE"
               },
               "Tags": []
           }
       }
   ]
   }
   ```

1. Sul nuovo nodo, crea due interfacce di rete virtuali (VNIs). Per ulteriori informazioni, consulta [Avvio dello storage compatibile con Amazon S3 sul servizio Snowball Edge](s3-edge-snow-setting-up.md#setting-up-s3-on-snow-cluster)

1. Utilizzate il `stop-service` comando per interrompere il servizio s3-snow.

   ```
   snowballEdge stop-service --service-id s3-snow --device-ip-addresses cluster-device-1-ip-address cluster-device-2-ip-address cluster-device-3-ip-address --manifest-file path/to/manifest/file.bin --unlock-code unlock-code --endpoint https://snow-device-ip-address                    
   ```  
**Example dell'output del comando `stop-service`**  

   ```
   Stopping the AWS service on your Snowball Edge. You can determine the status of the AWS service using the describe-service command.                                            
   ```

1. Usa il `start-service` comando per avviare il servizio s3-snow dopo aver aggiunto il nuovo nodo al cluster.

   ```
   snowballEdge start-service --service-id s3-snow --device-ip-addresses cluster-device-1-ip-address cluster-device-2-ip-address cluster-device-3-ip-address --virtual-network-interface-arns "device-1-vni-ip-address-a" "device-1-vni-ip-address-b" "device-2-vni-ip-address-a" "device-2-vni-ip-address-b" "device-3-vni-ip-address-a" "device-3-vni-ip-address-b" --manifest-file path/to/manifest/file.bin --unlock-code unlock-code --endpoint https://snow-device-ip-address                    
   ```  
**Example dell'output del comando `start-service`**  

   ```
   Starting the AWS service on your Snowball Edge. You can determine the status of the AWS service using the describe-service command.                        
   ```

1. Usa il `describe-service` comando per assicurarti che il servizio s3-snow sia avviato.

   ```
   snowballEdge describe-service --service-id s3-snow --device-ip-addresses snow-device-1-address snow-device-2-address snow-device-3-address --manifest-file path/to/manifest/file.bin --unlock-code unlock-code --endpoint https://snow-device-ip-address             
   ```  
**Example dell'output del comando `descibe-service`**  

   ```
   {
       "ServiceId": "s3-snow",
       "Autostart": true,
       "Status": {
           "State": "ACTIVE"
       },
       "ServiceCapacities": [{
           "Name": "S3 Storage",
           "Unit": "Byte",
           "Used": 38768180432,
           "Available": 82961231819568
       }],
       "Endpoints": [{
               "Protocol": "https",
               "Port": 443,
               "Host": "10.0.0.10",
               "CertificateAssociation": {
                   "CertificateArn": "arn:aws:snowball-device:::certificate/7Rg2lP9tQaHnW4sC6xUzF1vGyD3jB5kN8MwEiYpT"
               },
               "Description": "s3-snow bucket API endpoint (for s3control SDK)",
               "DeviceId": "JID12345678-1234-1234-1234-123456789012",
               "Status": {
                   "State": "ACTIVE"
               }
           }, {
               "Protocol": "https",
               "Port": 443,
               "Host": "10.0.0.11",
               "CertificateAssociation": {
                   "CertificateArn": "arn:aws:snowball-device:::certificate/7Rg2lP9tQaHnW4sC6xUzF1vGyD3jB5kN8MwEiYpT"
               },
               "Description": "s3-snow object & bucket API endpoint (for s3api SDK)",
               "DeviceId": "JID12345678-1234-1234-1234-123456789013",
               "Status": {
                   "State": "ACTIVE"
               }
           }, {
               "Protocol": "https",
               "Port": 443,
               "Host": "10.0.0.12",
               "CertificateAssociation": {
                   "CertificateArn": "arn:aws:snowball-device:::certificate/7Rg2lP9tQaHnW4sC6xUzF1vGyD3jB5kN8MwEiYpT"
               },
               "Description": "s3-snow bucket API endpoint (for s3control SDK)",
               "DeviceId": "JID12345678-1234-1234-1234-123456789015",
               "Status": {
                   "State": "ACTIVE"
               }
           }, {
               "Protocol": "https",
               "Port": 443,
               "Host": "10.0.0.13",
               "CertificateAssociation": {
                   "CertificateArn": "arn:aws:snowball-device:::certificate/7Rg2lP9tQaHnW4sC6xUzF1vGyD3jB5kN8MwEiYpT"
               },
               "Description": "s3-snow object & bucket API endpoint (for s3api SDK)",
               "DeviceId": "JID-beta-207012320001-24-02-05-17-17-27",
               "Status": {
                   "State": "ACTIVE"
               }
           }, {
               "Protocol": "https",
               "Port": 443,
               "Host": "10.0.0.14",
               "CertificateAssociation": {
                   "CertificateArn": "arn:aws:snowball-device:::certificate/7Rg2lP9tQaHnW4sC6xUzF1vGyD3jB5kN8MwEiYpT"
               },
               "Description": "s3-snow bucket API endpoint (for s3control SDK)",
               "DeviceId": "JID-beta-207012240003-24-02-05-17-17-28",
               "Status": {
                   "State": "ACTIVE"
               }
           }, {
               "Protocol": "https",
               "Port": 443,
               "Host": "10.0.0.15",
               "CertificateAssociation": {
                   "CertificateArn": "arn:aws:snowball-device:::certificate/7Rg2lP9tQaHnW4sC6xUzF1vGyD3jB5kN8MwEiYpT"
               },
               "Description": "s3-snow object & bucket API endpoint (for s3api SDK),
               "DeviceId": "JID-beta-207012320001-24-02-05-17-17-28",
               "Status": {
                   "State": "ACTIVE"
               }
           }
       }]
   }
   ```