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à.
# Creare un’AMI supportata da Amazon S3
L’AMI specificata quando avvii l’istanza determina il tipo di volume root.
Per creare un’AMI Linux supportata da Amazon S3, devi iniziare da un’istanza già avviata da un’AMI Linux supportata da Amazon S3. Dopo avere personalizzato l'istanza in base alle tue esigenze, è necessario creare un bundle del volume e registrare una nuova AMI, che puoi utilizzare per avviare nuove istanze con queste personalizzazioni.
Non puoi creare un'AMI Windows supportata da Amazon S3 perché Windows AMIs non supporta l'instance store per il volume root.
**Importante**
Solo i seguenti tipi di istanza supportano un volume di archivio dell’istanza come volume root e richiedono un’AMI supportata da Amazon S3: C1, C3, D2, I2, M1, M2, M3, R3 e X1.
Il processo di creazione di AMI è diverso per Amazon EBS AMIs. Per ulteriori informazioni, consulta [Creare un'AMI supportata da Amazon EBS](creating-an-ami-ebs.md).
**Topics**
+ [Panoramica della creazione delle AMI](#process-creating-an-ami-instance-store)
+ [Prerequisiti](#bundle-ami-prerequisites)
+ [Creare un'AMI da un'istanza Amazon Linux](#amazon_linux_instructions)
+ [Configurazione degli strumenti dell'AMI Amazon EC2](set-up-ami-tools.md)
+ [Riferimento agli strumenti Amazon EC2 AMI](ami-tools-commands.md)
+ [Converti la tua AMI supportata da Amazon S3 in una AMI supportata da EBS](Using_ConvertingS3toEBS.md)
## Panoramica della creazione delle AMI
Il diagramma seguente riepiloga le operazioni necessarie per la creazione di un’AMI a partire da un’istanza con un volume root di archivio dell’istanza.
![\[Creare un’AMI supportata da Amazon S3.\]](http://docs.aws.amazon.com/it_it/AWSEC2/latest/UserGuide/images/ami_create_instance_store.png)
Innanzitutto, avvia un'istanza da un'AMI che sia simile all'AMI che desideri creare. Puoi connetterti alla tua istanza e personalizzarla. Una volta che è configurata come desideri puoi creare un bundle dell'istanza. Per il completamento di questo processo sono richiesti vari minuti. Al termine del processo avrai un bundle, composto da un manifest delle immagini (`image.manifest.xml`) e da file (`image.part.`*xx*) contenenti un modello per il volume root. Successivamente, carica il bundle nel bucket Amazon S3 e registra l'AMI.
**Nota**
Per caricare oggetti in un bucket S3 per l’AMI Linux supportata da Amazon S3, devi abilitare le ACL per il bucket. In caso contrario, Amazon EC2 non sarà in grado di impostare ACLs gli oggetti da caricare. Se il bucket di destinazione utilizza l'impostazione imposta dal proprietario del bucket per S3 Object Ownership, questa impostazione non funzionerà perché sono disabilitati. ACLs Per ulteriori informazioni, consulta [Controllo della proprietà degli oggetti e ACLs disabilitazione del](https://docs.aws.amazon.com/AmazonS3/latest/userguide/about-object-ownership.html) bucket.
Quando avvii un'istanza con la nuova AMI, viene creato il volume root dell'istanza usando il bundle che hai caricato in Amazon S3. Finché non lo elimini, lo spazio di archiviazione utilizzato dal bundle in Amazon S3 comporta dei costi che vengono addebitati sul tuo account. Per ulteriori informazioni, consulta [Annullare la registrazione di un'AMI Amazon EC2](deregister-ami.md).
Se aggiungi dei volumi archivio dell’istanza all’istanza, oltre al volume root, la mappatura dei dispositivi a blocchi per la nuova AMI conterrà informazioni su tali volumi e le mappature dei dispositivi a blocchi per le istanze che avvii dalla nuova AMI conterranno automaticamente le informazioni relative a tali volumi. Per ulteriori informazioni, consulta [Mappature dei dispositivi a blocchi per i volumi sulle istanze Amazon EC2](block-device-mapping-concepts.md).
## Prerequisiti
Prima di poter creare un AMI, devi completare le attività seguenti:
+ Installazione degli strumenti AMI. Per ulteriori informazioni, consulta [Configurazione degli strumenti dell'AMI Amazon EC2](set-up-ami-tools.md).
+ Installa il. AWS CLI Per ulteriori informazioni, consulta [Nozioni di base di AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).
+ Assicurati di avere un bucket S3 per il pacchetto e che il bucket sia abilitato. ACLs [Per ulteriori informazioni sulla configurazione, consulta Configurazione ACLs. ACLs](https://docs.aws.amazon.com/AmazonS3/latest/userguide/managing-acls.html)
+ **Per creare un bucket S3 utilizzando Console di gestione AWS, apri la console Amazon S3 all'[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)indirizzo e scegli Create Bucket.**
+ [Per creare un bucket S3 con AWS CLI, puoi usare il comando mb.](https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html) Se la versione installata degli strumenti AMI è la 1.5.18 o successiva, per creare il bucket S3 puoi anche usare il comando `ec2-upload-bundle`. Per ulteriori informazioni, consulta [ec2-upload-bundle](ami-tools-commands.md#ami-upload-bundle).
+ Assicurati che i file del tuo bundle non siano crittografati nel bucket S3. Se hai bisogno della crittografia per la tua AMI, puoi invece utilizzare un'AMI supportata da EBS. Per ulteriori informazioni, consulta [Usa la crittografia con supporto EBS AMIs](AMIEncryption.md).
+ Assicurati di avere l'ID del tuo AWS account. Per ulteriori informazioni, consulta [Visualizza Account AWS gli identificatori](https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-identifiers.html) nella *Guida di riferimento per la gestione degli AWS account*.
+ Assicurati di disporre delle credenziali per utilizzare la AWS CLI. Per ulteriori informazioni, consulta [Authentication and access credentials for the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-authentication.html) nella *Guida per l’utente di AWS Command Line Interface *.
+ Verifica della disponibilità di un certificato X.509 e della chiave privata corrispondente.
+ Per creare un certificato X.509, consultare [Gestione dei certificati di firma](set-up-ami-tools.md#ami-tools-managing-certs). Il certificato X.509 e la chiave privata vengono utilizzati per codificare e decodificare l'AMI.
+ [Cina (Pechino)] Utilizza il certificato `$EC2_AMITOOL_HOME/etc/ec2/amitools/cert-ec2-cn-north-1.pem`.
+ [AWS GovCloud (US-West)] Usa il `$EC2_AMITOOL_HOME/etc/ec2/amitools/cert-ec2-gov.pem` certificato.
+ Connessione all'istanza e relativa personalizzazione. Ad esempio, è possibile installare software e applicazioni, copiare i dati, eliminare i file temporanei e modificare la configurazione Linux.
## Creare un'AMI da un'istanza Amazon Linux
Le seguenti procedure descrivono come creare un’AMI da un’istanza con un volume root di archivio dell’istanza che esegue Amazon Linux 1. Potrebbero non funzionare per le istanze in esecuzione su altre distribuzioni Linux.
**Per prepararsi a utilizzare gli strumenti AMI (solo istanze HVM)**
1. Per essere avviati correttamente, gli strumenti AMI necessitano di GRUB Legacy. Utilizzare il comando seguente per installare GRUB:
```
[ec2-user ~]$ sudo yum install -y grub
```
1. Installare i pacchetti di gestione delle partizioni usando il seguente comando:
```
[ec2-user ~]$ sudo yum install -y gdisk kpartx parted
```
**Per creare un’AMI da un’istanza Amazon Linux con un volume root di archivio dell’istanza**
Questa procedura presuppone che i prerequisiti indicati in [Prerequisiti](#bundle-ami-prerequisites) siano stati soddisfatti.
Nei seguenti comandi, sostituisci ciascuno *user input placeholder* con le tue informazioni.
1. Caricare le credenziali nell'istanza. Le credenziali servono a garantire l'accesso all'AMI solo da parte dell'utente e da Amazon EC2.
1. Creare una directory temporanea sull'istanza per le credenziali, come segue:
```
[ec2-user ~]$ mkdir /tmp/cert
```
In questo modo è possibile escludere le proprie credenziali dall'immagine creata.
1. Copiare il certificato X.509 e la chiave privata corrispondente dal proprio computer nella directory `/tmp/cert` sull'istanza utilizzando uno strumento di copia protetta come [scp](linux-file-transfer-scp.md). L'opzione `-i my-private-key.pem` nel comando **scp** seguente è la chiave privata da utilizzare per connettersi all'istanza con SSH, non la chiave privata X.509. Ad esempio:
```
you@your_computer:~ $ scp -i my-private-key.pem /path/to/pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem /path/to/cert-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem ec2-user@ec2-203-0-113-25.compute-1.amazonaws.com:/tmp/cert/
pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem 100% 717 0.7KB/s 00:00
cert-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem 100% 685 0.7KB/s 00:00
```
In alternativa, poiché questi sono file di testo normale, è possibile aprire il certificato e la chiave in un editor di testo e copiarne il contenuto in nuovi file in `/tmp/cert`.
1. Preparare il bundle da caricare in Amazon S3 eseguendo il comando [ec2-bundle-vol](ami-tools-commands.md#ami-bundle-vol) dall'istanza. Accertarsi di specificare l'opzione `-e` per escludere la directory in cui sono archiviate le proprie credenziali. Per impostazione predefinita, il processo di creazione di bundle esclude i file che possono contenere informazioni sensibili. Tali file includono `*.sw`, `*.swo`, `*.swp`, `*.pem`, `*.priv`, `*id_rsa*`, `*id_dsa*` `*.gpg`, `*.jks`, `*/.ssh/authorized_keys` e `*/.bash_history`. Per includere tutti questi file, utilizzare l'opzione `--no-filter`. Per includere alcuni di questi file, utilizzare l'opzione `--include`.
**Importante**
Per impostazione predefinita, il processo di raggruppamento dell'AMI crea una raccolta codificata di file nella directory `/tmp` che rappresenta il volume root. Se non è disponibile sufficiente spazio libero sul disco in `/tmp` per archiviare il bundle, occorre specificare una posizione diversa per il bundle da archiviare con l'opzione `-d /path/to/bundle/storage`. Alcune istanze dispongono di storage temporaneo montato su `/mnt` o `/media/ephemeral0` che è possibile utilizzare; in alternativa, è anche possibile creare, collegare e montare un nuovo volume Amazon EBS per l'archiviazione del bundle. Per ulteriori informazioni, consulta [Creare un volume di Amazon EBS](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-creating-volume.html) nella *Guida per l'utente di Amazon EBS*.
1. Il **ec2-bundle-vol** comando deve essere eseguito come root. Per la maggior parte dei comandi, è possibile utilizzare **sudo** per ottenere autorizzazioni elevate, ma in questo caso occorre eseguire **sudo -E su** per mantenere le variabili di ambiente.
```
[ec2-user ~]$ sudo -E su
```
Si noti che il prompt bash ora identifica l'utente come utente root e il simbolo del dollaro è stato sostituito da un tag hash, a segnalare che ci si trova in una shell root:
```
[root ec2-user]#
```
1. Per creare il bundle dell'AMI, eseguire il comando [ec2-bundle-vol](ami-tools-commands.md#ami-bundle-vol) come segue:
```
[root ec2-user]# ec2-bundle-vol -k /tmp/cert/pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem -c /tmp/cert/cert-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem -u 123456789012 -r x86_64 -e /tmp/cert --partition gpt
```
**Nota**
Per le regioni Cina (Pechino) e AWS GovCloud (Stati Uniti occidentali), utilizza il `--ec2cert` parametro e specifica i certificati in base ai [prerequisiti](#bundle-ami-prerequisites).
Possono essere necessari alcuni minuti per creare l'immagine. Al termine di questo comando, la directory `/tmp` (o quella non predefinita) contiene il pacchetto (`image.manifest.xml`oltre a più file). `image.part.` *xx*
1. Uscire dalla shell root.
```
[root ec2-user]# exit
```
1. (Facoltativo) Per aggiungere altri volumi instance store, modificare le mappature dei dispositivi a blocchi nel file `image.manifest.xml` dell'AMI. Per ulteriori informazioni, consulta [Mappature dei dispositivi a blocchi per i volumi sulle istanze Amazon EC2](block-device-mapping-concepts.md).
1. Creare un backup del file `image.manifest.xml`.
```
[ec2-user ~]$ sudo cp /tmp/image.manifest.xml /tmp/image.manifest.xml.bak
```
1. Riformattare il file `image.manifest.xml` per renderne più semplice la lettura e la modifica.
```
[ec2-user ~]$ sudo xmllint --format /tmp/image.manifest.xml.bak > /tmp/image.manifest.xml
```
1. Modificare le mappature dei dispositivi a blocchi in `image.manifest.xml` con un editor di testo. Il seguente esempio mostra una nuova voce del volume instance store `ephemeral1`.
**Nota**
Per un elenco dei file esclusi, consulta [ec2-bundle-vol](ami-tools-commands.md#ami-bundle-vol).
```
ami
sda
ephemeral0
sdb
ephemeral1
sdc
root
/dev/sda1
```
1. Salvare il file `image.manifest.xml` e uscire dall'editor di testo.
1. Per caricare il bundle su Amazon S3, eseguire il comando [ec2-upload-bundle](ami-tools-commands.md#ami-upload-bundle) come segue.
```
[ec2-user ~]$ ec2-upload-bundle -b amzn-s3-demo-bucket/bundle_folder/bundle_name -m /tmp/image.manifest.xml -a your_access_key_id -s your_secret_access_key
```
**Importante**
Per registrare l'AMI in una regione diversa da US East (N. Virginia), occorre specificare sia la regione di destinazione con l'opzione `--region` che un percorso del bucket esistente nella regione di destinazione oppure un percorso univoco del bucket che è possibile creare nella regione di destinazione.
1. (Facoltativo) Una volta caricato il bundle su Amazon S3, è possibile rimuoverlo dalla directory `/tmp` sull'istanza utilizzando il seguente comando **rm**:
```
[ec2-user ~]$ sudo rm /tmp/image.manifest.xml /tmp/image.part.* /tmp/image
```
**Importante**
Se si è specificato un percorso con l'opzione `-d /path/to/bundle/storage` in [Step 2](#step_with_bundle_path_amazon_linux), utilizzare quel percorso invece di `/tmp`.
1. Per registrare l'AMI, eseguire il comando [register-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) come segue.
```
[ec2-user ~]$ aws ec2 register-image --image-location amzn-s3-demo-bucket/bundle_folder/bundle_name/image.manifest.xml --name AMI_name --virtualization-type hvm
```
**Importante**
Se precedentemente si è specificata una regione per il comando [ec2-upload-bundle](ami-tools-commands.md#ami-upload-bundle), specificarla nuovamente per questo comando.
# Configurazione degli strumenti dell'AMI Amazon EC2
Puoi usare gli strumenti AMI per creare e gestire Linux basato su Amazon S3. AMIs Per usare gli strumenti, è necessario installarli sulla propria istanza Linux. Gli strumenti AMI sono disponibili sia come file RPM che come file .zip per le distribuzioni Linux che non supportano il formato RPM.
**Per configurare gli strumenti AMI tramite il file RPM**
1. Installare Ruby utilizzando il programma di gestione dei pacchetti per la distribuzione Linux in uso, come yum. Ad esempio:
```
[ec2-user ~]$ sudo yum install -y ruby
```
1. Scaricare il file RPM utilizzando uno strumento come wget o curl. Ad esempio:
```
[ec2-user ~]$ wget https://s3.amazonaws.com/ec2-downloads/ec2-ami-tools.noarch.rpm
```
1. Verificare la firma del file RPM tramite il seguente comando:
```
[ec2-user ~]$ rpm -K ec2-ami-tools.noarch.rpm
```
Il comando precedente dovrebbe indicare che gli hash SHA1 e gli MD5 hash del file sono `OK.` Se il comando indica che gli hash lo sono`NOT OK`, usa il seguente comando per visualizzare l'intestazione e gli hash del file: SHA1 MD5
```
[ec2-user ~]$ rpm -Kv ec2-ami-tools.noarch.rpm
```
Quindi, confronta l'intestazione SHA1 e gli MD5 hash del file con i seguenti hash verificati degli strumenti AMI per confermare l'autenticità del file:
+ Intestazione: a1f662d6f25f69871104e6a62187fa4df508f880 SHA1
+ MD5: 9faff05258064e2f7909b66142de6782
Se l'intestazione SHA1 e gli MD5 hash del file corrispondono agli hash verificati degli strumenti AMI, vai al passaggio successivo.
1. Installare il file RPM utilizzando il seguente comando:
```
[ec2-user ~]$ sudo yum install ec2-ami-tools.noarch.rpm
```
1. Verificare l'installazione degli strumenti AMI tramite il comando [ec2- ami-tools-version](ami-tools-commands.md#ami-tools-version).
```
[ec2-user ~]$ ec2-ami-tools-version
```
**Nota**
Se ricevi un errore di caricamento del tipo «cannot load such file -- ec2/amitools/version (LoadError)», completa il passaggio successivo per aggiungere la posizione dell'installazione degli strumenti AMI al tuo percorso. `RUBYLIB`
1. (Facoltativo) Se nella fase precedente si è ricevuto un errore, aggiungere la posizione dell'installazione degli strumenti AMI al percorso `RUBYLIB`.
1. Eseguire il seguente comando per determinare i percorsi da aggiungere.
```
[ec2-user ~]$ rpm -qil ec2-ami-tools | grep ec2/amitools/version
/usr/lib/ruby/site_ruby/ec2/amitools/version.rb
/usr/lib64/ruby/site_ruby/ec2/amitools/version.rb
```
Nell'esempio di cui sopra, il file mancante indicato nel precedente errore di caricamento si trova in `/usr/lib/ruby/site_ruby` e `/usr/lib64/ruby/site_ruby`.
1. Aggiungere le posizioni indicate nella fase precedente al percorso `RUBYLIB`.
```
[ec2-user ~]$ export RUBYLIB=$RUBYLIB:/usr/lib/ruby/site_ruby:/usr/lib64/ruby/site_ruby
```
1. Verificare l'installazione degli strumenti AMI tramite il comando [ec2- ami-tools-version](ami-tools-commands.md#ami-tools-version).
```
[ec2-user ~]$ ec2-ami-tools-version
```
**Per configurare gli strumenti AMI tramite il file .zip**
1. Installare Ruby e decomprimerlo utilizzando il programma di gestione dei pacchetti per la distribuzione Linux in uso, come **apt-get**. Ad esempio:
```
[ec2-user ~]$ sudo apt-get update -y && sudo apt-get install -y ruby unzip
```
1. Scaricare il file .zip utilizzando uno strumento come wget o curl. Ad esempio:
```
[ec2-user ~]$ wget https://s3.amazonaws.com/ec2-downloads/ec2-ami-tools.zip
```
1. Decomprimere i file in una directory di installazione adatta, come `/usr/local/ec2`.
```
[ec2-user ~]$ sudo mkdir -p /usr/local/ec2
$ sudo unzip ec2-ami-tools.zip -d /usr/local/ec2
```
Notate che il file.zip contiene una cartella ec2-ami-tools-. *x* *x*. *x*, dove*x*. *x*. *x*è il numero di versione degli strumenti (ad esempio,`ec2-ami-tools-1.5.7`).
1. Impostare la variabile di ambiente `EC2_AMITOOL_HOME` sulla posizione directory di installazione degli strumenti. Ad esempio:
```
[ec2-user ~]$ export EC2_AMITOOL_HOME=/usr/local/ec2/ec2-ami-tools-x.x.x
```
1. Aggiungere gli strumenti alla variabile di ambiente `PATH`. Ad esempio:
```
[ec2-user ~]$ export PATH=$EC2_AMITOOL_HOME/bin:$PATH
```
1. È possibile verificare l'installazione degli strumenti AMI tramite il comando [ec2- ami-tools-version](ami-tools-commands.md#ami-tools-version).
```
[ec2-user ~]$ ec2-ami-tools-version
```
## Gestione dei certificati di firma
Alcuni comandi negli strumenti AMI necessitano di un certificato di firma (noto anche come certificato X.509). È necessario creare il certificato e quindi caricarlo su AWS. Ad esempio, per creare il certificato puoi utilizzare uno strumento di terza parte come OpenSSL.
**Per creare un certificato di firma**
1. Installare e configurare OpenSSL
1. Creare una chiave privata usando il comando `openssl genrsa` e salvare l'output in un file `.pem`. È consigliabile creare una chiave RSA a 2048 o 4096 bit.
```
openssl genrsa 2048 > private-key.pem
```
1. Generare un certificato usando il comando `openssl req`.
```
openssl req -new -x509 -nodes -sha256 -days 365 -key private-key.pem -outform PEM -out certificate.pem
```
Per caricare il certificato su AWS, usa il [upload-signing-certificate](https://docs.aws.amazon.com/cli/latest/reference/iam/upload-signing-certificate.html)comando.
```
aws iam upload-signing-certificate --user-name user-name --certificate-body file://path/to/certificate.pem
```
Per elencare i certificati per un utente, usa il [list-signing-certificates](https://docs.aws.amazon.com/cli/latest/reference/iam/list-signing-certificates.html)comando:
```
aws iam list-signing-certificates --user-name user-name
```
Per disabilitare o riattivare un certificato di firma per un utente, usa il [update-signing-certificate](https://docs.aws.amazon.com/cli/latest/reference/iam/update-signing-certificate.html)comando. Il seguente comando disattiva il certificato:
```
aws iam update-signing-certificate --certificate-id OFHPLP4ZULTHYPMSYEX7O4BEXAMPLE --status Inactive --user-name user-name
```
Per eliminare un certificato, usa il [delete-signing-certificate](https://docs.aws.amazon.com/cli/latest/reference/iam/delete-signing-certificate.html)comando:
```
aws iam delete-signing-certificate --user-name user-name --certificate-id OFHPLP4ZULTHYPMSYEX7O4BEXAMPLE
```
# Riferimento agli strumenti Amazon EC2 AMI
Puoi usare i comandi AMI tools per creare e gestire Linux basato su Amazon S3. AMIs Per impostare gli strumenti, consultare [Configurazione degli strumenti dell'AMI Amazon EC2](set-up-ami-tools.md).
Per informazioni sulle chiavi di accesso, consulta [Gestione delle chiavi di accesso per gli utenti IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) nella *Guida per l'utente di IAM*.
**Topics**
+ [ec2- ami-tools-version](#ami-tools-version)
+ [ec2-bundle-image](#ami-bundle-image)
+ [ec2-bundle-vol](#ami-bundle-vol)
+ [ec2-delete-bundle](#ami-delete-bundle)
+ [ec2-download-bundle](#ami-download-bundle)
+ [ec2-migrate-manifest](#ami-migrate-manifest)
+ [ec2-unbundle](#ami-unbundle)
+ [ec2-upload-bundle](#ami-upload-bundle)
+ [Opzioni comuni per gli strumenti AMI](#common-args-ami)
## ec2- ami-tools-version
### Description
Descrive la versione degli strumenti AMI.
### Sintassi
**ec2-ami-tools-version**
### Output
Informazioni relative alla versione.
### Esempio
Questo comando di esempio mostra le informazioni relative alla versione degli strumenti AMI che si stanno utilizzando.
```
[ec2-user ~]$ ec2-ami-tools-version
1.5.2 20071010
```
## ec2-bundle-image
### Description
Crea un’AMI Linux supportata da Amazon S3 a partire da un’immagine del sistema operativo creata in un file di loopback.
### Sintassi
****ec2-bundle-image** -c *path* -k *path* -u *account* -i *path* [-d *path*] [--ec2cert *path*] [-r *architecture*] [--productcodes *code1*,*code2*,...] [-B *mapping*] [-p *prefix*]**
### Opzioni
`-c, --cert` *path*
Il file del certificato a chiave pubblica RSA codificato PEM dell'utente.
Campo obbligatorio: sì
`-k, --privatekey` *path*
Il percorso di un file chiave RSA codificato PEM. Sarà necessario specificare questa chiave per separare questo bundle, quindi conservarla in un posto sicuro. Tieni presente che la chiave non deve essere registrata sul tuo AWS account.
Obbligatorio: sì
`-u, --user ` *account*
L'ID dell' AWS account dell'utente, senza trattini.
Obbligatorio: sì
`-i, --image` *path*
Il percorso dell'immagine da aggiungere al bundle.
Campo obbligatorio: sì
`-d, --destination` *path*
La directory in cui creare il bundle.
Default: `/tmp`
Campo obbligatorio: no
`--ec2cert` *path*
Il percorso del certificato a chiave pubblica Amazon EC2 X.509 utilizzato per crittografare il manifesto dell'immagine.
Le regioni `us-gov-west-1` e `cn-north-1` utilizzano un certificato di chiave pubblico non predefinito e il percorso di tale certificato deve essere specificato con questa opzione. Il percorso del certificato varia in base al metodo di installazione degli strumenti AMI. Per Amazon Linux, i certificati si trovano in `/opt/aws/amitools/ec2/etc/ec2/amitools/`. Se gli strumenti AMI sono stati installati dal file RPM o ZIP in [Configurazione degli strumenti dell'AMI Amazon EC2](set-up-ami-tools.md), i certificati si trovano in `$EC2_AMITOOL_HOME/etc/ec2/amitools/`.
Obbligatorio: Solo per le regioni `us-gov-west-1` e `cn-north-1`.
`-r, --arch` *architecture*
Architettura dell'immagine. Se non si fornisce l'architettura sulla riga di comando, verrà richiesta durante l'avvio del raggruppamento.
Valori validi: `i386` \$1 `x86_64`
Campo obbligatorio: no
`--productcodes` *code1,code2,...*
I codici prodotto da collegare all'immagine al momento della registrazione, separati da virgole.
Campo obbligatorio: no
`-B, --block-device-mapping` *mapping*
Definisce come i dispositivi a blocchi sono esposti a un'istanza di questa AMI se il suo tipo di istanza supporta il dispositivo specificato.
Specificare un elenco di coppie chiave-valore separato da virgole, in cui ogni chiave è un nome virtuale e ogni valore è il nome del dispositivo corrispondente. Tra i nomi virtuali sono inclusi i seguenti:
+ `ami` – Il dispositivo di sistema del file radice visto dall'istanza
+ `root` – Il dispositivo di sistema del file radice visto dal kernel
+ `swap` – Il dispositivo di scambio visto dall'istanza
+ `ephemeralN` – Il volume Nesimo dell'instance store
Campo obbligatorio: no
`-p, --prefix` *prefix*
Il prefisso del nome del file per i file AMI raggruppati.
Predefinito: Il nome del file immagine. Per esempio, se il percorso dell'immagine è `/var/spool/my-image/version-2/debian.img`, il prefisso predefinito è `debian.img`.
Campo obbligatorio: no
`--kernel` *kernel\$1id*
Obsoleta. Utilizzare [register-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) per impostare il kernel.
Campo obbligatorio: no
`--ramdisk` *ramdisk\$1id*
Obsoleta. Utilizzare [register-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) per impostare il disco RAM se necessario.
Obbligatorio: no
### Output
Messaggi di stato che descrivono le fasi e lo stato del processo di raggruppamento.
### Esempio
Questo esempio crea un'AMI raggruppata da un'immagine del sistema operativo creata in un file di loopback.
```
[ec2-user ~]$ ec2-bundle-image -k pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem -c cert-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem -u 111122223333 -i image.img -d bundled/ -r x86_64
Please specify a value for arch [i386]:
Bundling image file...
Splitting bundled/image.gz.crypt...
Created image.part.00
Created image.part.01
Created image.part.02
Created image.part.03
Created image.part.04
Created image.part.05
Created image.part.06
Created image.part.07
Created image.part.08
Created image.part.09
Created image.part.10
Created image.part.11
Created image.part.12
Created image.part.13
Created image.part.14
Generating digests for each part...
Digests generated.
Creating bundle manifest...
ec2-bundle-image complete.
```
## ec2-bundle-vol
### Description
Crea un’AMI Linux supportata da Amazon S3 comprimendo, crittografando e firmando una copia del volume root per l’istanza.
Amazon EC2 tenta di ereditare codici prodotto, impostazioni del kernel, impostazioni del disco RAM e bloccare le mappature dei dispositivi dall'istanza.
Per impostazione predefinita, il processo di creazione di bundle esclude i file che possono contenere informazioni sensibili. Tali file includono `*.sw`, `*.swo`, `*.swp`, `*.pem`, `*.priv`, `*id_rsa*`, `*id_dsa*` `*.gpg`, `*.jks`, `*/.ssh/authorized_keys` e `*/.bash_history`. Per includere tutti questi file, utilizzare l'opzione `--no-filter`. Per includere alcuni di questi file, utilizzare l'opzione `--include`.
Per ulteriori informazioni, consulta [Creare un’AMI supportata da Amazon S3](creating-an-ami-instance-store.md).
### Sintassi
****ec2-bundle-vol** -c *path* -k *path* -u *account* [-d *path*] [--ec2cert *path*] [-r *architecture*] [--productcodes *code1*,*code2*,...] [-B *mapping*] [--all] [-e *directory1*,*directory2*,...] [-i *file1*,*file2*,...] [--no-filter] [-p *prefix*] [-s *size*] [--[no-]inherit] [-v *volume*] [-P *type*] [-S *script*] [--fstab *path*] [--generate-fstab] [--grub-config *path*]**
### Opzioni
`-c, --cert` *path*
Il file del certificato a chiave pubblica RSA codificato PEM dell'utente.
Campo obbligatorio: sì
`-k, --privatekey ` *path*
Il percorso del file chiave RSA codificato PEM dell'utente.
Campo obbligatorio: sì
`-u, --user` *account*
L'ID dell' AWS account dell'utente, senza trattini.
Obbligatorio: sì
`-d, --destination` *destination*
La directory in cui creare il bundle.
Default: `/tmp`
Campo obbligatorio: no
`--ec2cert` *path*
Il percorso del certificato a chiave pubblica Amazon EC2 X.509 utilizzato per crittografare il manifesto dell'immagine.
Le regioni `us-gov-west-1` e `cn-north-1` utilizzano un certificato di chiave pubblico non predefinito e il percorso di tale certificato deve essere specificato con questa opzione. Il percorso del certificato varia in base al metodo di installazione degli strumenti AMI. Per Amazon Linux, i certificati si trovano in `/opt/aws/amitools/ec2/etc/ec2/amitools/`. Se gli strumenti AMI sono stati installati dal file RPM o ZIP in [Configurazione degli strumenti dell'AMI Amazon EC2](set-up-ami-tools.md), i certificati si trovano in `$EC2_AMITOOL_HOME/etc/ec2/amitools/`.
Obbligatorio: Solo per le regioni `us-gov-west-1` e `cn-north-1`.
`-r, --arch ` *architecture*
L'architettura dell'immagine. Se non la si fornisce sulla riga di comando, verrà richiesto di fornirla durante l'avvio del raggruppamento.
Valori validi: `i386` \$1 `x86_64`
Campo obbligatorio: no
`--productcodes` *code1,code2,...*
I codici prodotto da collegare all'immagine al momento della registrazione, separati da virgole.
Campo obbligatorio: no
`-B, --block-device-mapping` *mapping*
Definisce come i dispositivi a blocchi sono esposti a un'istanza di questa AMI se il suo tipo di istanza supporta il dispositivo specificato.
Specificare un elenco di coppie chiave-valore separato da virgole, in cui ogni chiave è un nome virtuale e ogni valore è il nome del dispositivo corrispondente. Tra i nomi virtuali sono inclusi i seguenti:
+ `ami` – Il dispositivo di sistema del file radice visto dall'istanza
+ `root` – Il dispositivo di sistema del file radice visto dal kernel
+ `swap` – Il dispositivo di scambio visto dall'istanza
+ `ephemeralN` – Il volume Nesimo dell'instance store
Campo obbligatorio: no
`-a, --all`
Raggruppare tutte le directory, comprese quelle su sistemi di file montati in remoto.
Campo obbligatorio: no
`-e, --exclude ` *directory1,directory2,...*
Un elenco di percorsi e file di directory assoluti da escludere dall'operazione di creazione di bundle. Questo parametro sostituisce l'opzione `--all` . Quando si specifica l'opzione di esclusione, le directory e sottodirectory elencate con il parametro non verranno raggruppate con il volume.
Campo obbligatorio: no
`-i, --include ` *file1,file2,...*
Un elenco dei file da includere nell'operazione di creazione di bundle. I file specificati sarebbero altrimenti esclusi dall'AMI in quanto potrebbero contenere informazioni sensibili.
Campo obbligatorio: no
`--no-filter`
Se specificato, non verranno esclusi file dall'AMI in quanto potrebbero contenere informazioni sensibili.
Campo obbligatorio: no
`-p, --prefix ` *prefix*
Il prefisso del nome del file per i file AMI raggruppati.
Impostazione predefinita: `image`
Campo obbligatorio: no
`-s, --size` *size*
La dimensione, in MB (1024 x 1024 byte), del file di immagine da creare. La dimensione massima è 10240 MB.
Impostazione predefinita: 10240
Campo obbligatorio: no
`--[no-]inherit`
Indica se l'immagine deve ereditare i metadati dell'istanza (l'impostazione predefinita è ereditare). Il raggruppamento non va a buon fine se si attiva `--inherit` ma i metadati dell'istanza non sono accessibili.
Campo obbligatorio: no
`-v, --volume ` *volume*
Il percorso assoluto del volume montato da cui creare il bundle.
Impostazione predefinita: la directory radice (/)
Campo obbligatorio: no
`-P, --partition` *type*
Indica se l'immagine del disco deve utilizzare una tabella di partizione. Se non si specifica un tipo di tabella di partizione, quello predefinito è il tipo utilizzato dal principale dispositivo a blocchi del volume, se applicabile, altrimenti quello predefinito è `gpt`.
Valori validi: `mbr` \$1 `gpt` \$1 `none`
Campo obbligatorio: no
`-S, --script` *script*
Uno script di personalizzazione da eseguire appena prima del raggruppamento. Lo script deve aspettarsi un argomento singolo, il punto di montaggio del volume.
Campo obbligatorio: no
`--fstab` *path*
Il percorso di fstab da aggiungere in bundle all'immagine. Se questo non è specificato, Amazon EC2 raggruppa /etc/fstab.
Obbligatorio: no
`--generate-fstab`
Raggruppa il volume utilizzando un file fstab EC2 fornito da Amazon.
Obbligatorio: no
`--grub-config`
Il percorso di un file di configurazione di sgombero alternato da aggiungere in bundle all'immagine. Per impostazione predefinita, `ec2-bundle-vol` si aspetta che `/boot/grub/menu.lst` o `/boot/grub/grub.conf` esistano nell'immagine clonata. Questa opzione consente di indicare un percorso di un file di configurazione di sgombero alternato che poi verrà copiato sui predefiniti (se presenti).
Campo obbligatorio: no
`--kernel` *kernel\$1id*
Obsoleta. Utilizzare [register-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) per impostare il kernel.
Campo obbligatorio: no
`--ramdisk`*ramdisk\$1id*
Obsoleta. Utilizzare [register-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) per impostare il disco RAM se necessario.
Obbligatorio: no
### Output
Messaggi di stato che descrivono le fasi e lo stato del raggruppamento.
### Esempio
Questo esempio crea un'AMI raggruppata comprimendo, crittografando e firmando uno snapshot del sistema di file radice della macchina locale.
```
[ec2-user ~]$ ec2-bundle-vol -d /mnt -k pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem -c cert-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem -u 111122223333 -r x86_64
Copying / into the image file /mnt/image...
Excluding:
sys
dev/shm
proc
dev/pts
proc/sys/fs/binfmt_misc
dev
media
mnt
proc
sys
tmp/image
mnt/img-mnt
1+0 records in
1+0 records out
mke2fs 1.38 (30-Jun-2005)
warning: 256 blocks unused.
Splitting /mnt/image.gz.crypt...
Created image.part.00
Created image.part.01
Created image.part.02
Created image.part.03
...
Created image.part.22
Created image.part.23
Generating digests for each part...
Digests generated.
Creating bundle manifest...
Bundle Volume complete.
```
## ec2-delete-bundle
### Description
Elimina il bundle specificato dall'archiviazione Amazon S3. Dopo aver eliminato un bundle, non è possibile avviare istanze dall'AMI corrispondente.
### Sintassi
****ec2-delete-bundle** -b *bucket* -a *access\$1key\$1id* -s *secret\$1access\$1key* [-t *token*] [--url *url*] [--region *region*] [--sigv *version*] [-m *path*] [-p *prefix*] [--clear] [--retry] [-y]**
### Opzioni
`-b, --bucket `*bucket*
Il nome del bucket Amazon S3 che contiene l'AMI raggruppata, seguito da un prefisso facoltativo di percorso delimitato da "/"
Campo obbligatorio: sì
`-a, --access-key` *access\$1key\$1id*
L' AWS ID della chiave di accesso.
Obbligatorio: sì
`-s, --secret-key` *secret\$1access\$1key*
La chiave di accesso AWS segreta.
Obbligatorio: sì
`-t, --delegation-token` *token*
Il token di delega da passare alla AWS richiesta. Per ulteriori informazioni, consulta [Temporary security credentials](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) nella *Guida per l’utente IAM*.
Obbligatorio: Solo quando si utilizzano credenziali di sicurezza temporanee.
Predefinito: Il valore della variabile ambientale `AWS_DELEGATION_TOKEN` (se impostata).
`--region`*region*
La regione da utilizzare nella firma di richiesta.
Impostazione predefinita: `us-east-1`
Obbligatorio: Obbligatorio se si utilizza la versione 4 di firma
`--sigv`*version*
La versione della firma da utilizzare durante la firma della richiesta.
Valori validi: `2` \$1 `4`
Default: `4`
Campo obbligatorio: no
`-m, --manifest`*path*
Il percorso del file manifest.
Obbligatorio: È necessario specificare `--prefix` o `--manifest`.
`-p, --prefix` *prefix*
Il prefisso del nome del file AMI raggruppato. Fornire il prefisso completo. Per esempio, se il prefisso è image.img, utilizzare `-p image.img` e non `-p image`.
Obbligatorio: È necessario specificare `--prefix` o `--manifest`.
`--clear`
Cancella il bucket Amazon S3 se è vuoto dopo aver eliminato il bundle specificato.
Campo obbligatorio: no
`--retry`
Ripete automaticamente i tentativi su tutti gli errori Amazon S3, fino a cinque volte per operazione.
Campo obbligatorio: no
`-y, --yes`
Suppone automaticamente che la risposta a tutte le richieste sia sì.
Obbligatorio: no
### Output
Amazon EC2 visualizza messaggi di stato che indicano le fasi e lo stato del processo di eliminazione.
### Esempio
In questo esempio viene eliminato un bundle da Amazon S3.
```
[ec2-user ~]$ ec2-delete-bundle -b amzn-s3-demo-bucket -a your_access_key_id -s your_secret_access_key
Deleting files:
amzn-s3-demo-bucket/image.manifest.xml
amzn-s3-demo-bucket/image.part.00
amzn-s3-demo-bucket/image.part.01
amzn-s3-demo-bucket/image.part.02
amzn-s3-demo-bucket/image.part.03
amzn-s3-demo-bucket/image.part.04
amzn-s3-demo-bucket/image.part.05
amzn-s3-demo-bucket/image.part.06
Continue? [y/n]
y
Deleted amzn-s3-demo-bucket/image.manifest.xml
Deleted amzn-s3-demo-bucket/image.part.00
Deleted amzn-s3-demo-bucket/image.part.01
Deleted amzn-s3-demo-bucket/image.part.02
Deleted amzn-s3-demo-bucket/image.part.03
Deleted amzn-s3-demo-bucket/image.part.04
Deleted amzn-s3-demo-bucket/image.part.05
Deleted amzn-s3-demo-bucket/image.part.06
ec2-delete-bundle complete.
```
## ec2-download-bundle
### Description
Scarica il sistema Linux supportato da Amazon S3 specificato AMIs dallo storage Amazon S3.
### Sintassi
****ec2-download-bundle** -b *bucket* -a *access\$1key\$1id* -s *secret\$1access\$1key* -k *path* [--url *url*] [--region *region*] [--sigv *version*] [-m *file*] [-p *prefix*] [-d *directory*] [--retry]**
### Opzioni
`-b, --bucket` *bucket*
Il nome del bucket Amazon S3 dove è posizionato il bundle, seguito da un prefisso facoltativo di percorso delimitato da "/".
Campo obbligatorio: sì
`-a, --access-key` *access\$1key\$1id*
L'ID della chiave di AWS accesso.
Obbligatorio: sì
`-s, --secret-key` *secret\$1access\$1key*
La chiave di accesso AWS segreta.
Obbligatorio: sì
`-k, --privatekey` *path*
La chiave privata utilizzata per decrittografare il manifest.
Campo obbligatorio: sì
`--url` *url*
L'URL di servizio Amazon S3.
Default: `https://s3.amazonaws.com/`
Campo obbligatorio: no
`--region` *region*
La regione da utilizzare nella firma di richiesta.
Impostazione predefinita: `us-east-1`
Obbligatorio: Obbligatorio se si utilizza la versione 4 di firma
`--sigv` *Versione*
La versione della firma da utilizzare durante la firma della richiesta.
Valori validi: `2` \$1 `4`
Default: `4`
Campo obbligatorio: no
`-m, --manifest` *file*
Il nome del file manifest (senza il percorso). Si consiglia di specificare il manifest (`-m`) o un prefisso (`-p`).
Campo obbligatorio: no
`-p, --prefix ` *prefix*
Il prefisso del nome del file per i file AMI raggruppati.
Impostazione predefinita: `image`
Campo obbligatorio: no
`-d, --directory ` *directory*
La directory dove viene salvato il bundle scaricato. La directory deve esistere.
Predefinito: La directory di lavoro corrente.
Campo obbligatorio: no
`--retry`
Ripete automaticamente i tentativi su tutti gli errori Amazon S3, fino a cinque volte per operazione.
Obbligatorio: no
### Output
Vengono visualizzati i messaggi di stato che indicano le varie fasi del processo di download.
### Esempio
Questo esempio crea la directory `bundled` (tramite il comando di Linux **mkdir**) e scarica il bundle dal bucket Amazon S3 `amzn-s3-demo-bucket`.
```
[ec2-user ~]$ mkdir bundled
[ec2-user ~]$ ec2-download-bundle -b amzn-s3-demo-bucket/bundles/bundle_name -m image.manifest.xml -a your_access_key_id -s your_secret_access_key -k pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem -d mybundle
Downloading manifest image.manifest.xml from amzn-s3-demo-bucket to mybundle/image.manifest.xml ...
Downloading part image.part.00 from amzn-s3-demo-bucket/bundles/bundle_name to mybundle/image.part.00 ...
Downloaded image.part.00 from amzn-s3-demo-bucket
Downloading part image.part.01 from amzn-s3-demo-bucket/bundles/bundle_name to mybundle/image.part.01 ...
Downloaded image.part.01 from amzn-s3-demo-bucket
Downloading part image.part.02 from amzn-s3-demo-bucket/bundles/bundle_name to mybundle/image.part.02 ...
Downloaded image.part.02 from amzn-s3-demo-bucket
Downloading part image.part.03 from amzn-s3-demo-bucket/bundles/bundle_name to mybundle/image.part.03 ...
Downloaded image.part.03 from amzn-s3-demo-bucket
Downloading part image.part.04 from amzn-s3-demo-bucket/bundles/bundle_name to mybundle/image.part.04 ...
Downloaded image.part.04 from amzn-s3-demo-bucket
Downloading part image.part.05 from amzn-s3-demo-bucket/bundles/bundle_name to mybundle/image.part.05 ...
Downloaded image.part.05 from amzn-s3-demo-bucket
Downloading part image.part.06 from amzn-s3-demo-bucket/bundles/bundle_name to mybundle/image.part.06 ...
Downloaded image.part.06 from amzn-s3-demo-bucket
```
## ec2-migrate-manifest
### Description
Modifica un’AMI Linux supportata da Amazon S3 (per esempio, il suo certificato, il kernel o il disco RAM) in modo che essa supporti una regione diversa.
### Sintassi
****ec2-migrate-manifest** -c *path* -k *path* -m *path* \$1(-a *access\$1key\$1id* -s *secret\$1access\$1key* --region *region*) \$1 (--no-mapping)\$1 [--ec2cert *ec2\$1cert\$1path*] [--kernel *kernel-id*] [--ramdisk *ramdisk\$1id*]**
### Opzioni
`-c, --cert` *path*
Il file del certificato a chiave pubblica RSA codificato PEM dell'utente.
Campo obbligatorio: sì
`-k, --privatekey` *path*
Il percorso del file chiave RSA codificato PEM dell'utente.
Campo obbligatorio: sì
`--manifest` *path*
Il percorso del file manifest.
Campo obbligatorio: sì
`-a, --access-key` *access\$1key\$1id*
L'ID della chiave di AWS accesso.
Obbligatorio: Obbligatorio se si utilizza la mappatura automatica.
`-s, --secret-key ` *secret\$1access\$1key*
La chiave di accesso AWS segreta.
Obbligatorio: Obbligatorio se si utilizza la mappatura automatica.
`--region` *region*
La regione da cercare nel file di mappatura.
Obbligatorio: Obbligatorio se si utilizza la mappatura automatica.
`--no-mapping`
Disattiva la mappatura automatica dei kernel e dei dischi RAM.
Durante la migrazione, Amazon EC2 sostituisce il kernel e il disco RAM nel file manifest con un disco kernel e RAM progettato per la regione di destinazione. A meno che non venga fornito il parametro `--no-mapping`, `ec2-migrate-bundle` deve utilizzare le operazioni `DescribeRegions` e `DescribeImages` per eseguire le mappature automatiche.
Obbligatorio: Obbligatorio se non si forniscono le opzioni `-a`, `-s` e `--region` utilizzate per la mappatura automatica.
`--ec2cert` *path*
Il percorso del certificato a chiave pubblica Amazon EC2 X.509 utilizzato per crittografare il manifesto dell'immagine.
Le regioni `us-gov-west-1` e `cn-north-1` utilizzano un certificato di chiave pubblico non predefinito e il percorso di tale certificato deve essere specificato con questa opzione. Il percorso del certificato varia in base al metodo di installazione degli strumenti AMI. Per Amazon Linux, i certificati si trovano in `/opt/aws/amitools/ec2/etc/ec2/amitools/`. Se gli strumenti AMI sono stati installati dal file ZIP in [Configurazione degli strumenti dell'AMI Amazon EC2](set-up-ami-tools.md), i certificati si trovano in `$EC2_AMITOOL_HOME/etc/ec2/amitools/`.
Obbligatorio: Solo per le regioni `us-gov-west-1` e `cn-north-1`.
`--kernel` *kernel\$1id*
L'ID del kernel da selezionare.
È consigliabile utilizzare PV-GRUB invece dei kernel e dei dischi RAM. Per ulteriori informazioni, consulta [Kernel forniti dall'utente](https://docs.aws.amazon.com/linux/al2/ug/UserProvidedKernels.html) nella *Guida per l'utente di Amazon Linux 2*.
Obbligatorio: no
`--ramdisk` *ramdisk\$1id*
L'ID del disco RAM da selezionare.
È consigliabile utilizzare PV-GRUB invece dei kernel e dei dischi RAM. Per ulteriori informazioni, consulta [Kernel forniti dall'utente](https://docs.aws.amazon.com/linux/al2/ug/UserProvidedKernels.html) nella *Guida per l'utente di Amazon Linux 2*.
Obbligatorio: no
### Output
Messaggi di stato che descrivono le fasi e lo stato del processo di raggruppamento.
### Esempio
Questo esempio copia l'AMI specificata nel manifest `my-ami.manifest.xml` dagli Stati Uniti all'Unione Europea.
```
[ec2-user ~]$ ec2-migrate-manifest --manifest my-ami.manifest.xml --cert cert-HKZYKTAIG2ECMXYIBH3HXV4ZBZQ55CLO.pem --privatekey pk-HKZYKTAIG2ECMXYIBH3HXV4ZBZQ55CLO.pem --region eu-west-1
Backing up manifest...
Successfully migrated my-ami.manifest.xml It is now suitable for use in eu-west-1.
```
## ec2-unbundle
### Description
Ricrea il bundle da un’AMI Linux supportata da Amazon S3.
### Sintassi
****ec2-unbundle** -k *path* -m *path* [-s *source\$1directory*] [-d *destination\$1directory*]**
### Opzioni
`-k, --privatekey` *path*
Il percorso del file chiave RSA codificato PEM.
Campo obbligatorio: sì
`-m, --manifest` *path*
Il percorso del file manifest.
Campo obbligatorio: sì
`-s, --source` *source\$1directory*
La directory che contiene il bundle.
Predefinita: La directory attuale.
Campo obbligatorio: no
`-d, --destination` *destination\$1directory*
La directory in cui disaggregare l'AMI. La directory di destinazione deve esistere.
Predefinita: La directory attuale.
Obbligatorio: no
### Esempio
Questo esempio Linux e UNIX disaggrega l'AMI specificata nel file `image.manifest.xml`.
```
[ec2-user ~]$ mkdir unbundled
$ ec2-unbundle -m mybundle/image.manifest.xml -k pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem -s mybundle -d unbundled
$ ls -l unbundled
total 1025008
-rw-r--r-- 1 root root 1048578048 Aug 25 23:46 image.img
```
### Output
Vengono visualizzati i messaggi di stato che indicano le varie fasi del processo di disaggregazione.
## ec2-upload-bundle
### Description
Carica il pacchetto per un'AMI Linux supportata da Amazon S3 su Amazon S3 e imposta gli elenchi di controllo degli accessi appropriati ACLs () sugli oggetti caricati. Per ulteriori informazioni, consulta [Creare un’AMI supportata da Amazon S3](creating-an-ami-instance-store.md).
**Nota**
Per caricare oggetti su un bucket S3 per la tua AMI Linux supportata da Amazon S3ACLs , devi essere abilitato per il bucket. In caso contrario, Amazon non EC2 sarà in grado di impostare ACLs gli oggetti da caricare. Se il bucket di destinazione utilizza l'impostazione imposta dal proprietario del bucket per S3 Object Ownership, questa impostazione non funzionerà perché sono disabilitati. ACLs Per ulteriori informazioni, consulta [Controllo della proprietà degli oggetti e ACLs disabilitazione del](https://docs.aws.amazon.com/AmazonS3/latest/userguide/about-object-ownership.html) bucket.
### Sintassi
****ec2-upload-bundle** -b *bucket* -a *access\$1key\$1id* -s *secret\$1access\$1key* [-t *token*] -m *path* [--url *url*] [--region *region*] [--sigv *version*] [--acl *acl*] [-d *directory*] [--part *part*] [--retry] [--skipmanifest]**
### Opzioni
`-b, --bucket` *bucket*
Il nome del bucket Amazon S3 dove memorizzare il bundle, seguito da un prefisso facoltativo di percorso delimitato da "/". Se il bucket non esiste, viene creato se il nome del bucket è disponibile. Inoltre, se il bucket non esiste e la versione degli strumenti AMI è 1.5.18 o successiva, questo comando imposta il ACLs bucket.
Obbligatorio: sì
`-a, --access-key` *access\$1key\$1id*
L'ID della tua chiave AWS di accesso.
Obbligatorio: sì
`-s, --secret-key` *secret\$1access\$1key*
La tua chiave di accesso AWS segreta.
Obbligatorio: sì
`-t, --delegation-token` *token*
Il token di delega da passare alla AWS richiesta. Per ulteriori informazioni, consulta [Temporary security credentials](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) nella *Guida per l’utente IAM*.
Obbligatorio: Solo quando si utilizzano credenziali di sicurezza temporanee.
Predefinito: Il valore della variabile ambientale `AWS_DELEGATION_TOKEN` (se impostata).
`-m, --manifest` *path*
Il percorso del file manifest. Il file manifest viene creato durante il processo di raggruppamento e si può trovare nella directory che contiene il bundle.
Campo obbligatorio: sì
`--url` *url*
Obsoleta. Invece, utilizzare l'opzione `--region` a meno che il bucket non sia limitato alla posizione `EU` (e non `eu-west-1`). Il contrassegno `--location` è l'unico modo per mirare a quella specifica limitazione di posizione.
L'URL di servizio endpoint Amazon S3.
Default: `https://s3.amazonaws.com/`
Campo obbligatorio: no
`--region` *region*
La regione da utilizzare nella firma di richiesta per il bucket S3 di destinazione.
+ Se il bucket non esiste e non si specifica una regione, lo strumento crea il bucket senza un vincolo di posizione (in `us-east-1`).
+ Se il bucket non esiste e si specifica una regione, lo strumento crea il bucket nella regione specificata.
+ Se il bucket esiste e non si specifica una regione, lo strumento utilizza la posizione del bucket.
+ Se il bucket esiste e si specifica `us-east-1` come regione, lo strumento utilizza la posizione reale del bucket senza alcun messaggio di errore e senza che i file corrispondenti esistenti vengano sovrascritti.
+ Se il bucket esiste e si specifica una regione (diversa da `us-east-1`) che non corrisponde alla posizione reale del bucket, lo strumento dà un errore.
Se il bucket è limitato alla posizione `EU` (e non `eu-west-1`), utilizzare il contrassegno `--location`. Il contrassegno `--location` è l'unico modo per mirare a quella specifica limitazione di posizione.
Impostazione predefinita: `us-east-1`
Obbligatorio: Obbligatorio se si utilizza la versione 4 di firma
`--sigv` *Versione*
La versione della firma da utilizzare durante la firma della richiesta.
Valori validi: `2` \$1 `4`
Default: `4`
Campo obbligatorio: no
`--acl` *acl*
La policy della lista di controllo accessi dell'immagine raggruppata.
Valori validi: `public-read` \$1 `aws-exec-read`
Default: `aws-exec-read`
Campo obbligatorio: no
`-d, --directory` *directory*
La directory che contiene le parti dell'AMI raggruppata.
Predefinito: La directory che contiene il file manifest (consultare l'opzione `-m`).
Campo obbligatorio: no
`--part` *part*
Inizia a caricare la parte specificata e tutte le parti successive. Ad esempio, `--part 04`.
Campo obbligatorio: no
`--retry`
Ripete automaticamente i tentativi su tutti gli errori Amazon S3, fino a cinque volte per operazione.
Campo obbligatorio: no
`--skipmanifest`
Non carica il manifest.
Campo obbligatorio: no
`--location` *location*
Obsoleta. Invece, utilizzare l'opzione `--region`, a meno che il bucket non sia limitato alla posizione `EU` (e non `eu-west-1`). Il contrassegno `--location` è l'unico modo per mirare a quella specifica limitazione di posizione.
La limitazione di posizione del bucket Amazon S3 di destinazione. Se il bucket esiste e si specifica una posizione che non corrisponde alla posizione reale del bucket, lo strumento dà un errore. Se il bucket esiste e non si specifica una posizione, lo strumento utilizza la posizione del bucket. Se il bucket non esiste e si specifica una posizione, lo strumento crea il bucket nella posizione specificata. Se il bucket non esiste e non si specifica una posizione, lo strumento crea il bucket senza un vincolo di posizione (in `us-east-1`).
Predefinito: Se `--region` viene specificato, viene impostata la posizione per quella regione specificata. Se `--region` non viene specificata, la posizione predefinita è `us-east-1`.
Obbligatorio: no
### Output
Amazon EC2 visualizza messaggi di stato che indicano le fasi e lo stato del processo di caricamento.
### Esempio
Questo esempio carica il bundle specificato dal manifest `image.manifest.xml`.
```
[ec2-user ~]$ ec2-upload-bundle -b amzn-s3-demo-bucket/bundles/bundle_name -m image.manifest.xml -a your_access_key_id -s your_secret_access_key
Creating bucket...
Uploading bundled image parts to the S3 bucket amzn-s3-demo-bucket ...
Uploaded image.part.00
Uploaded image.part.01
Uploaded image.part.02
Uploaded image.part.03
Uploaded image.part.04
Uploaded image.part.05
Uploaded image.part.06
Uploaded image.part.07
Uploaded image.part.08
Uploaded image.part.09
Uploaded image.part.10
Uploaded image.part.11
Uploaded image.part.12
Uploaded image.part.13
Uploaded image.part.14
Uploading manifest ...
Uploaded manifest.
Bundle upload completed.
```
## Opzioni comuni per gli strumenti AMI
La maggior parte degli strumenti AMI accettano i parametri facoltativi seguenti.
`--help, -h`
Visualizza il messaggio di aiuto.
`--version`
Visualizza la versione e l'avviso di copyright.
`--manual`
Visualizza l'immissione manuale.
`--batch`
Funziona in modalità batch, sopprimendo le richieste interattive.
`--debug`
Visualizza le informazioni che possono essere utili durante la risoluzione dei problemi.
# Converti la tua AMI supportata da Amazon S3 in una AMI supportata da EBS
Puoi convertire un’AMI Linux supportata da Amazon S3 di tua proprietà in un’AMI Linux supportata da Amazon EBS.
**Importante**
Non puoi convertire un'AMI che non è di tua proprietà.
**Per convertire un’AMI supportata da Amazon S3 in un’AMI supportata da Amazon EBS**
1. Avviare un'istanza Amazon Linux da un'AMI Amazon EBS-backed. Per ulteriori informazioni, consulta [Avviare un'istanza EC2 tramite la procedura guidata di avvio dell'istanza nella console](ec2-launch-instance-wizard.md). Le istanze Amazon Linux hanno gli strumenti AWS CLI e AMI preinstallati.
1. Carica la chiave privata X.509 che hai utilizzato per raggruppare la tua AMI supportata da Amazon S3 nella tua istanza. Questa chiave serve a garantire l'accesso all'AMI solo da parte dell'utente e da Amazon EC2.
1. Creare una directory temporanea sull'istanza per la chiave privata X.509, come segue:
```
[ec2-user ~]$ mkdir /tmp/cert
```
1. Copiare la chiave privata X.509 dal proprio computer nella directory `/tmp/cert` sull'istanza utilizzando uno strumento di copia protetta come [scp](linux-file-transfer-scp.md). Il *my-private-key* parametro nel comando seguente è la chiave privata che usi per connetterti alla tua istanza con SSH. Esempio:
```
you@your_computer:~ $ scp -i my-private-key.pem /path/to/pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem ec2-user@ec2-203-0-113-25.compute-1.amazonaws.com:/tmp/cert/
pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem 100% 717 0.7KB/s 00:00
```
1. Configura le tue variabili ambiente per usare la AWS CLI. Per ulteriori informazioni, consulta [Variabili di ambiente](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html).
1. (Consigliato) Imposta le variabili di ambiente per la chiave di AWS accesso, la chiave segreta e il token di sessione.
```
[ec2-user ~]$ export AWS_ACCESS_KEY_ID=your_access_key_id
[ec2-user ~]$ export AWS_SECRET_ACCESS_KEY=your_secret_access_key
[ec2-user ~]$ export AWS_SESSION_TOKEN=your_session_token
```
1. Imposta le variabili di ambiente per la chiave di AWS accesso e la chiave segreta.
```
[ec2-user ~]$ export AWS_ACCESS_KEY_ID=your_access_key_id
[ec2-user ~]$ export AWS_SECRET_ACCESS_KEY=your_secret_access_key
```
1. Preparare un volume Amazon Elastic Block Store (Amazon EBS) per la nuova AMI.
1. Creare un volume EBS vuoto nella stessa zona di disponibilità dell'istanza utilizzando il comando [create-volume](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-volume.html). Prendere nota dell'ID del volume nell'output del comando.
**Importante**
Questo volume EBS deve essere uguale o maggiore delle dimensioni del volume root instance store originale.
```
aws ec2 create-volume \
--size 10 \
--region us-west-2 \
--availability-zone us-west-2b
```
1. Collegare il volume all'istanza supportata da Amazon EBS utilizzando il comando [attach-volume](https://docs.aws.amazon.com/cli/latest/reference/ec2/attach-volume.html).
```
aws ec2 attach-volume \
--volume-id vol-01234567890abcdef \
--instance-id i-1234567890abcdef0 \
--region us-west-2
```
1. Creare una cartella per il bundle.
```
[ec2-user ~]$ mkdir /tmp/bundle
```
1. Scaricare il bundle dell'AMI basata su instance store in `/tmp/bundle` utilizzando il comando [ec2-download-bundle](ami-tools-commands.md#ami-download-bundle).
```
[ec2-user ~]$ ec2-download-bundle -b amzn-s3-demo-bucket/bundle_folder/bundle_name -m image.manifest.xml -a $AWS_ACCESS_KEY_ID -s $AWS_SECRET_ACCESS_KEY --privatekey /path/to/pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem -d /tmp/bundle
```
1. Ricostruire il file di immagine dal bundle utilizzando il comando [ec2-unbundle](ami-tools-commands.md#ami-unbundle).
1. Cambiare directory nella cartella del bundle.
```
[ec2-user ~]$ cd /tmp/bundle/
```
1. Esegui il comando [ec2-unbundle](ami-tools-commands.md#ami-unbundle).
```
[ec2-user bundle]$ ec2-unbundle -m image.manifest.xml --privatekey /path/to/pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem
```
1. Copiare i file dall'immagine disaggregata nel nuovo volume EBS.
```
[ec2-user bundle]$ sudo dd if=/tmp/bundle/image of=/dev/sdb bs=1M
```
1. Esaminare il volume cercando eventuali partizioni disaggregate.
```
[ec2-user bundle]$ sudo partprobe /dev/sdb1
```
1. Elencare i dispositivi a blocchi per individuare il nome del dispositivo da montare.
```
[ec2-user bundle]$ lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
/dev/sda 202:0 0 8G 0 disk
└─/dev/sda1 202:1 0 8G 0 part /
/dev/sdb 202:80 0 10G 0 disk
└─/dev/sdb1 202:81 0 10G 0 part
```
In questo esempio, la partizione da montare è `/dev/sdb1`, ma il nome del dispositivo probabilmente sarà diverso. Se il volume non è partizionato, il dispositivo da montare sarà simile a `/dev/sdb` (senza una cifra finale della partizione del dispositivo).
1. Creare un punto di montaggio per il nuovo volume EBS e montare il volume.
```
[ec2-user bundle]$ sudo mkdir /mnt/ebs
[ec2-user bundle]$ sudo mount /dev/sdb1 /mnt/ebs
```
1. Aprire il file `/etc/fstab` sul volume EBS con l'editor di testo preferito (ad esempio **vim** o **nano**) e rimuovere tutte le voci dei volumi instance store (temporanei). Poiché il volume EBS è montato su `/mnt/ebs`, il file `fstab` si trova in `/mnt/ebs/etc/fstab`.
```
[ec2-user bundle]$ sudo nano /mnt/ebs/etc/fstab
#
LABEL=/ / ext4 defaults,noatime 1 1
tmpfs /dev/shm tmpfs defaults 0 0
devpts /dev/pts devpts gid=5,mode=620 0 0
sysfs /sys sysfs defaults 0 0
proc /proc proc defaults 0 0
/dev/sdb /media/ephemeral0 auto defaults,comment=cloudconfig 0 2
```
In questo esempio, l'ultima riga deve essere rimossa.
1. Smontare il volume e distaccarlo dall'istanza.
```
[ec2-user bundle]$ sudo umount /mnt/ebs
[ec2-user bundle]$ aws ec2 detach-volume --volume-id vol-01234567890abcdef --region us-west-2
```
1. Creare un'AMI dal nuovo volume EBS come segue:
1. Creare uno snapshot del nuovo volume EBS.
```
[ec2-user bundle]$ aws ec2 create-snapshot --region us-west-2 --description "your_snapshot_description" --volume-id vol-01234567890abcdef
```
1. Controllare se la snapshot è completa.
```
[ec2-user bundle]$ aws ec2 describe-snapshots --region us-west-2 --snapshot-id snap-0abcdef1234567890
```
1. Identificare l'architettura del processore, il tipo di virtualizzazione e l'immagine del kernel (`aki`) utilizzati sull'AMI originale tramite il comando **describe-images**. Per questa fase è necessario l’ID AMI dell’AMI originale supportato da Amazon S3.
```
[ec2-user bundle]$ aws ec2 describe-images --region us-west-2 --image-id ami-0abcdef1234567890 --output text
IMAGES x86_64 amazon/amzn-ami-pv-2013.09.2.x86_64-s3 ami-8ef297be amazon available public machine aki-fc8f11cc instance-store paravirtual xen
```
In questo esempio, l'architettura è `x86_64` e l'ID dell'immagine del kernel è `aki-fc8f11cc`. Utilizzare questi valori nella fase seguente. Se l'output del comando sopra include anche un ID `ari`, prenderne nota.
1. Registrare la nuova AMI con l'ID dello snapshot del nuovo volume EBS e i valori della fase precedente. Se nell'output del comando precedente è incluso un ID `ari`, includerlo nel seguente comando con `--ramdisk-id ari_id`.
```
[ec2-user bundle]$ aws ec2 register-image --region us-west-2 --name your_new_ami_name --block-device-mappings DeviceName=device-name,Ebs={SnapshotId=snap-0abcdef1234567890} --virtualization-type paravirtual --architecture x86_64 --kernel-id aki-fc8f11cc --root-device-name device-name
```
1. (Facoltativo) Dopo avere verificato di poter avviare un'istanza dalla nuova AMI, è possibile eliminare il volume EBS creato per questa procedura.
```
aws ec2 delete-volume --volume-id vol-01234567890abcdef
```