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 delle istanze per CodeDeploy
CodeDeploy supporta distribuzioni su istanze che eseguono Amazon Linux, Ubuntu Server, Red Hat Enterprise Linux (RHEL) e Windows Server.
Puoi utilizzarlo CodeDeploy per eseguire la distribuzione sia su istanze Amazon EC2 che su istanze locali. Un'istanza locale è qualsiasi dispositivo fisico diverso da un'istanza Amazon EC2 in grado di eseguire CodeDeploy l'agente e connettersi agli endpoint del AWS servizio pubblico. Puoi utilizzarla CodeDeploy per distribuire contemporaneamente un'applicazione su istanze Amazon EC2 nel cloud e PCs sul desktop del tuo ufficio o sui server del tuo data center.
## Confronto tra istanze Amazon EC2 e istanze locali
La tabella seguente mette a confronto le istanze di Amazon EC2 e le istanze locali:
| **Oggetto** | **Istanze Amazon EC2** | **Istanze locali** |
| --- | --- | --- |
| Richiede l'installazione e l'esecuzione di una versione dell' CodeDeploy agente compatibile con il sistema operativo in esecuzione sull'istanza. | Sì | Sì |
| Richiede che l'istanza sia in grado di connettersi a CodeDeploy. | Sì | Sì |
| Richiede il collegamento di un profilo di istanza IAM all'istanza. Il profilo dell'istanza IAM deve disporre delle autorizzazioni per partecipare alle CodeDeploy distribuzioni. Per informazioni, consulta [Fase 4: crea un profilo di istanza IAM per le tue istanze Amazon EC2](getting-started-create-iam-instance-profile.md). | Sì | No |
| Richiede che vengano eseguite le operazioni elencate di seguito per autenticare e registrare le istanze: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/instances.html) | No | Sì |
| Richiede la registrazione di ogni istanza CodeDeploy prima di poterla implementare. | No | Sì |
| Richiede di etichettare ogni istanza prima di CodeDeploy poter essere distribuita su di essa. | Sì | Sì |
| Può partecipare agli scenari di Amazon EC2 Auto Scaling ed Elastic Load Balancing come parte delle distribuzioni. CodeDeploy | Sì | No |
| Può essere distribuito da GitHub bucket e repository Amazon S3. | Sì | Sì |
| Può supportare i trigger che richiedono l'invio di notifiche SMS o e-mail quando nelle distribuzioni o nelle istanze si verificano eventi specifici. | Sì | Sì |
| È soggetta a essere fatturata per le distribuzioni associate. | No | Sì |
## Attività di istanza per CodeDeploy
Per avviare o configurare le istanze per l'uso nelle distribuzioni, scegliere tra le seguenti istruzioni:
| | |
| --- |--- |
| Voglio lanciare una nuova istanza Amazon Linux o Windows Server Amazon EC2. | Per avviare l'istanza Amazon EC2 con il minimo sforzo, consulta. [Crea un'istanza Amazon EC2 per CodeDeploy (modello)CloudFormation](instances-ec2-create-cloudformation-template.md) Per avviare l'istanza Amazon EC2 principalmente da soli, consulta. [Crea un'istanza Amazon EC2 per CodeDeploy (AWS CLI o una console Amazon EC2)](instances-ec2-create.md) |
| Voglio lanciare una nuova istanza di Ubuntu Server o RHEL Amazon EC2. | Per informazioni, consulta [Crea un'istanza Amazon EC2 per CodeDeploy (AWS CLI o una console Amazon EC2)](instances-ec2-create.md). |
| Voglio configurare un'istanza Amazon Linux, Windows Server, Ubuntu Server o RHEL Amazon EC2. | Per informazioni, consulta [Configura un'istanza Amazon EC2 con cui lavorare CodeDeploy](instances-ec2-configure.md). |
| Voglio configurare un'istanza locale di Windows Server, Ubuntu Server o RHEL (dispositivi fisici che non sono istanze Amazon EC2). | Per informazioni, consulta [Utilizzo di istanze locali per CodeDeploy](instances-on-premises.md). |
| Desidero effettuare CodeDeploy il provisioning di un parco istanze sostitutivo durante una distribuzione. blue/green | Per informazioni, consulta [Utilizzo delle distribuzioni in CodeDeploy](deployments.md). |
Per preparare le istanze Amazon EC2 nei gruppi Amazon EC2 Auto Scaling, devi seguire alcuni passaggi aggiuntivi. Per ulteriori informazioni, consulta [Integrazione CodeDeploy con Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md).
**Argomenti**
+ [Tagging Instances for Deployments](instances-tagging.md)
+ [Working with Amazon EC2 Instances](instances-ec2.md)
+ [Working with On-Premises Instances](instances-on-premises.md)
+ [View Instance Details](instances-view-details.md)
+ [Instance Health](instances-health.md)
# Taggare le istanze per i gruppi di distribuzione in CodeDeploy
Per aiutarti a gestire le istanze Amazon EC2 e le istanze locali, puoi utilizzare i tag per assegnare i tuoi metadati a ciascuna risorsa. I tag ti consentono di categorizzare le tue istanze in modi diversi (ad esempio, per scopo, proprietario o ambiente). Ciò risulta particolarmente utile quando si dispone di numerose istanze. È possibile individuare rapidamente un'istanza o un gruppo di istanze in base al tag assegnato. Ogni tag è composto da una chiave e da un valore opzionale, entrambi personalizzabili. Per ulteriori informazioni, consulta [Tagging your Amazon EC2 resources](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html).
*Per specificare quali istanze sono incluse in un gruppo di CodeDeploy distribuzione, devi specificare i tag in uno o più gruppi di tag.* Le istanze che soddisfano i criteri di tag sono quelle su cui è installata l'ultima versione dell'applicazione quando viene creata una distribuzione nel gruppo di distribuzione.
**Nota**
Puoi anche includere gruppi di Amazon EC2 Auto Scaling nei gruppi di distribuzione, ma sono identificati dai loro nomi anziché dai tag applicati alle istanze. Per informazioni, consulta [Integrazione CodeDeploy con Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md).
I criteri per le istanze in un gruppo di distribuzione possono essere semplici come un unico tag in un singolo gruppo di tag. È possibile includere fino a 10 tag in totale in un massimo di tre gruppi di tag.
Se si utilizza un singolo gruppo di tag, qualsiasi istanza del gruppo identificata da almeno un tag viene inclusa nel gruppo di distribuzione. Se si utilizzano più gruppi di tag, vengono incluse solo le istanze che sono identificate da almeno un tag in *ciascuno* dei gruppi di tag.
I seguenti esempi illustrano come possono essere utilizzati i tag e i gruppi di tag per selezionare le istanze per un gruppo di distribuzione.
**Topics**
+ [Esempio 1: gruppo di tag singolo, tag singolo](#instances-tagging-example-1)
+ [Esempio 2: gruppo di tag singolo, tag multipli](#instances-tagging-example-2)
+ [Esempio 3: gruppi di tag multipli, tag singoli](#instances-tagging-example-3)
+ [Esempio 4: gruppi di tag multipli, tag multipli](#instances-tagging-example-4)
## Esempio 1: gruppo di tag singolo, tag singolo
È possibile specificare un singolo tag in un singolo gruppo di tag:
**Gruppo di tag 1**
| Chiave | Valore |
| --- | --- |
| Name | AppVersion-ABC |
Ogni istanza che contiene il tag `Name=AppVersion-ABC` è parte del gruppo di distribuzione, anche a essa sono applicati altri tag.
CodeDeploy visualizzazione della configurazione della console:
![\[La CodeDeploy console mostra un gruppo di tag con un solo tag.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/TaggingExample1-polaris.png)
Struttura JSON:
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Name",
"Value": "AppVersion-ABC"
}
]
]
},
```
## Esempio 2: gruppo di tag singolo, tag multipli
È possibile anche specificare tag multipli in un singolo gruppo di tag:
**Gruppo di tag 1**
| Chiave | Valore |
| --- | --- |
| Region | Nord |
| Region | Sud |
| Region | Est |
Un'istanza che contiene il tag con uno qualsiasi di questi tre tag è parte del gruppo di distribuzione, anche se presenta altri tag applicati. Se, ad esempio, si dispone di altre istanze con il tag `Region=West`, queste potrebbero non essere incluse nel gruppo di distribuzione.
CodeDeploy visualizzazione della configurazione della console:
![\[La CodeDeploy console mostra un gruppo di tag con tre tag.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/TaggingExample2-polaris.png)
Struttura JSON:
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "North"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "South"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "East"
}
]
]
},
```
## Esempio 3: gruppi di tag multipli, tag singoli
È inoltre possibile utilizzare più insiemi di gruppi di tag con una singola coppia chiave-valore in ciascuno per specificare i criteri per le istanze in un gruppo di distribuzione. Quando si utilizzano più gruppi di tag in un gruppo di distribuzione, sono incluse nel gruppo di distribuzione solo le istanze che sono identificate da tutti i gruppi di tag.
**Gruppo di tag 1**
| Chiave | Valore |
| --- | --- |
| Name | AppVersion-ABC |
**Gruppo di tag 2**
| Chiave | Valore |
| --- | --- |
| Region | Nord |
**Gruppo di tag 3**
| Chiave | Valore |
| --- | --- |
| Tipo | t2.medium |
Le istanze contrassegnate con il tag `Name=AppVersion-ABC` potrebbero essere in numerose regioni e di vari tipi. In questo esempio, solo le istanze che sono contrassegnate anche con i tag `Region=North` e `Type=t2.medium` fanno parte del gruppo di distribuzione.
CodeDeploy visualizzazione della configurazione della console:
![\[La CodeDeploy console mostra tre gruppi di tag con un tag ciascuno.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/TaggingExample3-polaris.png)
Struttura JSON:
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Name",
"Value": "AppVersion-ABC"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "North"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Type",
"Value": "t2.medium"
}
],
]
},
```
## Esempio 4: gruppi di tag multipli, tag multipli
Quando usi più gruppi di tag con diversi tag in uno o più gruppi, un'istanza deve corrispondere ad almeno uno dei tag in ciascuno dei gruppi.
**Gruppo di tag 1**
| Chiave | Valore |
| --- | --- |
| Ambiente | Beta |
| Ambiente | Gestione temporanea |
**Gruppo di tag 2**
| Chiave | Valore |
| --- | --- |
| Region | Nord |
| Region | Sud |
| Region | Est |
**Gruppo di tag 3**
| Chiave | Valore |
| --- | --- |
| Tipo | t2.medium |
| Tipo | t2.large |
In questo esempio, per essere inclusa nel gruppo di distribuzione, un'istanza deve avere un tag (1) `Environment=Beta` o `Environment=Staging`, con (2) `Region=North`, `Region=South` oppure `Region=East` e con (3) `Type=t2.medium` o `Type=t2.large`.
A scopo illustrativo, le istanze con i seguenti gruppi di tag *sarebbero* tra quelle incluse nel gruppo di distribuzione:
+ `Environment=Beta`, `Region=North`,`Type=t2.medium`
+ `Environment=Staging`,`Region=East`,`Type=t2.large`
+ `Environment=Staging`,`Region=South`,`Type=t2.large`
Le istanze con i seguenti gruppi di tag *non* sarebbero tra quelle incluse nel gruppo di distribuzione. I valori chiave **evidenziati** causano l'esclusione delle istanze:
+ `Environment=Beta`, Region=**West**,`Type=t2.medium`
+ `Environment=Staging`,`Region=East`,Type=**t2.micro**
+ Environment=**Production**,`Region=South`,`Type=t2.large`
CodeDeploy visualizzazione della configurazione della console:
![\[La CodeDeploy console mostra tre gruppi di tag con più tag ciascuno.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/TaggingExample4-polaris.png)
Struttura JSON:
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Environment",
"Value": "Beta"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Environment",
"Value": "Staging"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "North"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "South"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "East"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Type",
"Value": "t2.medium"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Type",
"Value": "t2.large"
}
],
]
},
```
# Utilizzo delle istanze Amazon EC2 per CodeDeploy
Un'istanza Amazon EC2 è un ambiente di elaborazione virtuale che puoi creare e configurare utilizzando Amazon Elastic Compute Cloud. Amazon EC2 offre capacità di elaborazione scalabile nel cloud. AWS Puoi usare Amazon EC2 per lanciare tutti o pochi server virtuali di cui hai bisogno per le tue CodeDeploy distribuzioni.
Per ulteriori informazioni su Amazon EC2, consulta la Amazon EC2 Getting [https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/) Guide.
Le istruzioni in questa sezione mostrano come creare e configurare istanze Amazon EC2 da utilizzare nelle distribuzioni. CodeDeploy
**Topics**
+ [Crea un'istanza Amazon EC2 per CodeDeploy](instances-ec2-create.md)
+ [Crea un'istanza Amazon EC2 (modello)CloudFormation](instances-ec2-create-cloudformation-template.md)
+ [Configurare un'istanza Amazon EC2](instances-ec2-configure.md)
# Crea un'istanza Amazon EC2 per CodeDeploy (AWS CLI o una console Amazon EC2)
Queste istruzioni mostrano come avviare una nuova istanza Amazon EC2 configurata per l'uso nelle CodeDeploy distribuzioni.
Puoi utilizzare il nostro CloudFormation modello per avviare un'istanza Amazon EC2 che esegue Amazon Linux o Windows Server già configurata per l'uso nelle CodeDeploy distribuzioni. Non forniamo un CloudFormation modello per le istanze Amazon EC2 che eseguono Ubuntu Server o Red Hat Enterprise Linux (RHEL). Per le alternative per l'uso del modello, consulta [Utilizzo delle istanze per CodeDeploy](instances.md).
Puoi utilizzare la console Amazon EC2 o le API di Amazon EC2 per avviare un'istanza Amazon EC2. AWS CLI
## Avvia un'istanza Amazon EC2 (console)
### Prerequisiti
Se non l'hai già fatto, segui le istruzioni riportate [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md) per configurare AWS CLI e creare un profilo di istanza IAM.
### Avviare un'istanza Amazon EC2
1. Accedi Console di gestione AWS e apri la console Amazon EC2 all'indirizzo. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Nel riquadro di navigazione, scegliere **Instances (Istanze)**, quindi selezionare **Launch Instance (Avvia istanza)**.
1. Nella pagina **Fase 1: scegliere una Amazon Machine Image (AMI),**, dalla scheda **Quick Start**, individuare il sistema operativo e la versione che si desidera utilizzare e quindi scegliere **Seleziona**. Devi scegliere un sistema operativo AMI Amazon EC2 supportato da. CodeDeploy Per ulteriori informazioni, consulta [Sistemi operativi supportati dall'agente CodeDeploy](codedeploy-agent.md#codedeploy-agent-supported-operating-systems).
1. Nella pagina **Fase 2: Scegli un tipo di istanza**, scegli qualsiasi tipo di istanza Amazon EC2 disponibile, quindi scegli **Avanti: Configure Instance** Details.
1. Nella pagina **Fase 3: Configurazione dei dettagli dell'istanza**, nell'elenco dei **ruoli IAM, scegli il ruolo** dell'istanza IAM in [Fase 4: crea un profilo di istanza IAM per le tue istanze Amazon EC2](getting-started-create-iam-instance-profile.md) cui hai creato. Se hai utilizzato il nome del ruolo suggerito, scegli **CodeDeployDemo-EC2-Instance-Profile**. Se hai creato il nome del ruolo, sceglilo.
**Nota**
Se un cloud privato virtuale (VPC) predefinito non viene visualizzato nell'elenco **Rete**, devi scegliere o creare un Amazon VPC e una sottorete. Scegli **Crea nuovo VPC** o **Crea una nuova sottorete** o entrambe le opzioni. Per ulteriori informazioni, consulta [Il tuo VPC e](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html) le tue sottoreti.
1. Scegli **Passaggio successivo: aggiunta dello storage**.
1. Lascia la pagina **Step 4: Add Storage (Fase 4: aggiunta spazio di archiviazione)** invariata e seleziona **Next: Add Tags (Fase successiva: aggiunta di tag)**.
1. Nella pagina **Step 5: Add Tags (Fase 5: aggiunta di tag)**, scegli **Add tag (Aggiungi tag)**.
1. Nella casella **Key (Chiave)**, digita **Name**. Nella casella **Value (Valore)**, digita **CodeDeployDemo**.
**Importante**
Per il contenuto delle caselle **Key (Chiave)** e **Value (Valore)** viene rilevata la distinzione tra maiuscole e minuscole.
1. Scegliere **Next: Configure Security Group (Fase successiva: configurazione del gruppo di sicurezza)**.
1. Nella pagina **Step 6: Configure Security Group (Fase 6: configurare i gruppi di sicurezza)** verificare che l'opzione **Create a new security group (Crea un nuovo gruppo di sicurezza)** sia selezionata.
Un ruolo SSH predefinito è configurato per le istanze Amazon EC2 che eseguono Amazon Linux, Ubuntu Server o RHEL. Un ruolo RDP predefinito è configurato per le istanze Amazon EC2 che eseguono Windows Server.
1. Per aprire la porta HTTP, scegliere il pulsante **Add Rule (Aggiungi regola)** quindi, dall'elenco a discesa **Tipo**, scegliere **HTTP**. Accettare il valore **Origine** predefinito di **Personalizzato 0.0.0.0/0**, quindi scegliere **Rivedi e avvia**.
**Nota**
**In un ambiente di produzione, consigliamo di limitare l'accesso alle porte SSH, RDP e HTTP, invece di specificare Anywhere 0.0.0.0/0.** CodeDeploy non richiede l'accesso illimitato alle porte e non richiede l'accesso HTTP. Per ulteriori informazioni, consulta [Suggerimenti per proteggere l'istanza Amazon EC2](https://aws.amazon.com/articles/1233).
Se viene visualizzata la finestra di dialogo **Boot from General Purpose (SSD) (Avvio da General Purpose (SSD))**, seguire le istruzioni e scegliere **Next (Avanti)**.
1. Lasciare invariate le impostazioni nella pagina **Step 7: Review Instance Launch (Fase 7: verificare l'avvio dell'istanza)** e scegliere **Launch (Avvia)**.
1. Nella finestra di dialogo **Select an existing key pair or create a new key pair (Seleziona una coppia di chiavi esistenti o crea una nuova coppia di chiavi)** scegliere **Choose an existing key pair (Scegli una coppia di chiavi esistente)** o **Create a new key pair (Crea una nuova coppia di chiavi)**. Se hai già configurato una coppia di chiavi dell'istanza Amazon EC2 instance, è possibile sceglierla in questa pagina.
Se invece non hai ancora una coppia di chiavi dell'istanza Amazon EC2, scegli **Create a new key pair (Crea una nuova coppia di chiavi)** e assegnale un nome riconoscibile. Scegli **Scarica Key Pair** per scaricare la coppia di chiavi dell'istanza Amazon EC2 sul tuo computer.
**Importante**
È necessario disporre di una coppia di chiavi se si desidera accedere all'istanza Amazon EC2 con SSH o RDP.
1. Scegliere **Launch Instances** (Avvia istanze).
1. Scegli l'ID per la tua istanza Amazon EC2. Non continuare fino a quando l'istanza non viene avviata e non ha superato tutti i controlli.
### Installa l'agente CodeDeploy
L' CodeDeploy agente deve essere installato sull'istanza Amazon EC2 prima di utilizzarlo nelle CodeDeploy distribuzioni. Per ulteriori informazioni, consulta [Installa l' CodeDeploy agente](codedeploy-agent-operations-install.md).
**Nota**
Puoi configurare l'installazione e gli aggiornamenti automatici dell' CodeDeploy agente quando crei il gruppo di distribuzione nella console.
## Avvia un'istanza Amazon EC2 (CLI)
### Prerequisiti
Se non l'hai già fatto, segui le istruzioni riportate [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md) per impostare e configurare AWS CLI e creare un profilo di istanza IAM.
### Avviare un'istanza Amazon EC2
1. **Solo per Windows Server** Se stai creando un'istanza Amazon EC2 che esegue Windows Server, chiama i **authorize-security-group-ingress** comandi **create-security-group** and per creare un gruppo di sicurezza che consenta l'accesso RDP (che non è consentito di default) e, in alternativa, l'accesso HTTP. Ad esempio, per creare un gruppo di sicurezza denominato *CodeDeployDemo-Windows-Security-Group, esegui i seguenti comandi*, uno alla volta:
```
aws ec2 create-security-group --group-name CodeDeployDemo-Windows-Security-Group --description "For launching Windows Server images for use with CodeDeploy"
```
```
aws ec2 authorize-security-group-ingress --group-name CodeDeployDemo-Windows-Security-Group --to-port 3389 --ip-protocol tcp --cidr-ip 0.0.0.0/0 --from-port 3389
```
```
aws ec2 authorize-security-group-ingress --group-name CodeDeployDemo-Windows-Security-Group --to-port 80 --ip-protocol tcp --cidr-ip 0.0.0.0/0 --from-port 80
```
**Nota**
A scopo dimostrativo, questi comandi creano un gruppo di sicurezza che consente l'accesso illimitato per RDP attraverso la porta 3389 e, in alternativa, l'accesso HTTP attraverso la porta 80. Come best practice, è consigliabile limitare l'accesso alle porte RDP e HTTP. CodeDeploy non richiede l'accesso illimitato alle porte e non richiede l'accesso HTTP. Per ulteriori informazioni, consulta [Suggerimenti per proteggere l'istanza Amazon EC2](https://aws.amazon.com/articles/1233).
1. Chiama il **run-instances** comando per creare e avviare l'istanza Amazon EC2.
Prima di chiamare questo comando, devi raccogliere le informazioni seguenti:
+ L'ID di un'Amazon Machine Image (AMI) (*ami-id*) che usi per l'istanza. Per ottenere l'ID, consulta [Ricerca di un'AMI adatta](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/finding-an-ami.html).
+ Il nome del tipo di istanza Amazon EC2 (*instance-type*) che crei, ad esempio. `t1.micro` Per un elenco, consulta Tipi di [istanze Amazon EC2](https://aws.amazon.com/ec2/instance-types/).
+ Il nome di un profilo di istanza IAM con autorizzazione ad accedere al bucket Amazon S3 in cui sono archiviati i file di installazione dell' CodeDeploy agente per la tua regione.
Per informazioni sulla creazione di un profilo di istanza IAM, consulta. [Fase 4: crea un profilo di istanza IAM per le tue istanze Amazon EC2](getting-started-create-iam-instance-profile.md)
+ Il nome di una coppia di chiavi di istanza Amazon EC2 (*key-name*) per abilitare l'accesso SSH a un'istanza Amazon EC2 che esegue Amazon Linux, Ubuntu Server o l'accesso RHEL o RDP a un'istanza Amazon EC2 che esegue Windows Server.
**Importante**
Digita solo il nome della coppia di chiavi, non l'estensione del file della coppia di chiavi. Ad esempio, *my-keypair*, non *my-keypair.pem*.
[Per trovare il nome di una coppia di chiavi, apri la console Amazon EC2 all'indirizzo https://console.aws.amazon.com /ec2.](https://console.aws.amazon.com/ec2) Nel pannello di navigazione, in **Network & Security (Rete e sicurezza)**, scegliere **Key Pairs (Coppie di chiavi)** e annotare il nome della coppia di chiavi nell'elenco.
Per generare una coppia di chiavi, consulta [Creazione di una coppia di chiavi con Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html#having-ec2-create-your-key-pair). Assicurati di creare la key pair in una delle regioni elencate in [Regione e gli endpoint](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in *Riferimenti generali di AWS*. Altrimenti, non sarai in grado di utilizzare la coppia di chiavi dell'istanza Amazon EC2 con. CodeDeploy
**Per Amazon Linux, RHEL e Ubuntu Server**
Per richiamare il **run-instances** comando per avviare un'istanza Amazon EC2 che esegue Amazon Linux, Ubuntu Server o RHEL e collegare il profilo dell'istanza IAM in cui è stato creato. [Fase 4: crea un profilo di istanza IAM per le tue istanze Amazon EC2](getting-started-create-iam-instance-profile.md) Esempio:
```
aws ec2 run-instances \
--image-id ami-id \
--key-name key-name \
--count 1 \
--instance-type instance-type \
--iam-instance-profile Name=iam-instance-profile
```
**Nota**
Questo comando crea un gruppo di sicurezza predefinito per l'istanza Amazon EC2 che consente l'accesso a diverse porte, incluso l'accesso illimitato per SSH tramite la porta 22 e, in alternativa, HTTP tramite la porta 80. Come best practice, consigliamo di limitare l'accesso solo alle porte SSH e HTTP. CodeDeploy non richiede l'accesso illimitato alle porte e non richiede l'accesso alla porta HTTP. Per ulteriori informazioni, consulta [Suggerimenti per proteggere l'istanza Amazon EC2](https://aws.amazon.com/articles/1233).
**Per Windows Server**
Richiamare il **run-instances** comando per avviare un'istanza Amazon EC2 che esegue Windows Server e collegare il profilo dell'istanza IAM in [Fase 4: crea un profilo di istanza IAM per le tue istanze Amazon EC2](getting-started-create-iam-instance-profile.md) cui è stato creato e specificare il nome del gruppo di sicurezza creato nel passaggio 1. Esempio:
```
aws ec2 run-instances --image-id ami-id --key-name key-name --count 1 --instance-type instance-type --iam-instance-profile Name=iam-instance-profile --security-groups CodeDeploy-Windows-Security-Group
```
Questi comandi avviano una singola istanza Amazon EC2 con l'AMI, la coppia di chiavi e il tipo di istanza specificati, con il profilo di istanza IAM specificato ed eseguono lo script specificato durante l'avvio.
1. Prendere nota del valore di `InstanceID` nell'output. Se dimentichi questo valore, puoi ottenerlo in un secondo momento chiamando il **describe-instances** comando sulla coppia di chiavi dell'istanza Amazon EC2.
```
aws ec2 describe-instances --filters "Name=key-name,Values=keyName" --query "Reservations[*].Instances[*].[InstanceId]" --output text
```
Usa l'ID dell'istanza per chiamare il **create-tags** comando, che contrassegna l'istanza Amazon EC2 in modo che CodeDeploy possa trovarla in un secondo momento durante una distribuzione. Nell'esempio seguente, il tag è denominato**CodeDeployDemo**, ma puoi specificare qualsiasi tag di istanza Amazon EC2 che desideri.
```
aws ec2 create-tags --resources instance-id --tags Key=Name,Value=CodeDeployDemo
```
È possibile applicare più tag alla stessa istanza contemporaneamente. Esempio:
```
aws ec2 create-tags --resources instance-id --tags Key=Name,Value=testInstance Key=Region,Value=West Key=Environment,Value=Beta
```
Per verificare che l'istanza Amazon EC2 sia stata avviata e abbia superato tutti i controlli, usa l'ID dell'istanza per chiamare il **describe-instance-status** comando.
```
aws ec2 describe-instance-status --instance-ids instance-id --query "InstanceStatuses[*].InstanceStatus.[Status]" --output text
```
Se l'istanza è stata avviata e ha superato tutti i controlli, nell'output sarà presente `ok`:
### Installa l'agente CodeDeploy
L' CodeDeploy agente deve essere installato sull'istanza Amazon EC2 prima di utilizzarlo nelle CodeDeploy distribuzioni. Per ulteriori informazioni, consulta [Installa l' CodeDeploy agente](codedeploy-agent-operations-install.md).
**Nota**
Puoi configurare l'installazione e gli aggiornamenti automatici dell' CodeDeploy agente quando crei il gruppo di distribuzione nella console.
# Crea un'istanza Amazon EC2 per CodeDeploy (modello)CloudFormation
Puoi utilizzare il nostro CloudFormation modello per avviare rapidamente un'istanza Amazon EC2 che esegue Amazon Linux o Windows Server. Puoi usare il AWS CLI, la CodeDeploy console o il AWS APIs per avviare l'istanza con il modello. Oltre a lanciare l'istanza, il modello effettua le seguenti operazioni:
+ Indica CloudFormation di concedere all'istanza l'autorizzazione a partecipare alle CodeDeploy distribuzioni.
+ Etichetta l'istanza in modo da CodeDeploy poterla trovare durante una distribuzione.
+ Installa ed esegue l' CodeDeploy agente sull'istanza.
Non è necessario utilizzare la nostra CloudFormation per configurare un'istanza Amazon EC2. Per le alternative, consulta [Utilizzo delle istanze per CodeDeploy](instances.md).
Non forniamo un CloudFormation modello per le istanze Amazon EC2 che eseguono Ubuntu Server o Red Hat Enterprise Linux (RHEL).
**Topics**
+ [Prima di iniziare](#instances-ec2-create-cloudformation-template-before)
+ [Avvia un'istanza Amazon EC2 con il CloudFormation modello (console)](#instances-ec2-create-cloudformation-template-console)
+ [Avvia un'istanza Amazon EC2 con il CloudFormation modello ()AWS CLI](#instances-ec2-create-cloudformation-template-cli)
## Prima di iniziare
Prima di poter utilizzare il CloudFormation modello per avviare le istanze Amazon EC2, assicurati di completare i seguenti passaggi.
1. Assicurati di aver creato un utente amministrativo, come descritto in. [Fase 1: Configurazione](getting-started-setting-up.md) Ricontrolla che l'utente disponga delle seguenti autorizzazioni minime e aggiungi quelle che non sono presenti:
+ formazione di nuvole: \$1
+ codedeploy:\$1
+ ec2:\$1
+ obiettivo: AddRoleToInstanceProfile
+ sono: CreateInstanceProfile
+ sono: CreateRole
+ sono: DeleteInstanceProfile
+ sono: DeleteRole
+ sono: DeleteRolePolicy
+ sono: GetRole
+ sono: DeleteRolePolicy
+ sono: PutRolePolicy
+ sono: RemoveRoleFromInstanceProfile
1. Assicurati di disporre di una coppia di chiavi di istanza per abilitare l'accesso SSH all'istanza Amazon EC2 che esegue Amazon Linux o l'accesso RDP all'istanza che esegue Windows Server.
[Per trovare il nome di una coppia di chiavi, apri la console Amazon EC2 all'indirizzo https://console.aws.amazon.com /ec2.](https://console.aws.amazon.com/ec2) Nel pannello di navigazione, in **Network & Security (Rete e sicurezza)**, scegliere **Key Pairs (Coppie di chiavi)** e annotare il nome della coppia di chiavi nell'elenco.
Per generare una nuova coppia di chiavi, consulta [Creating your key pair using Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html#having-ec2-create-your-key-pair). Assicurati che la key pair sia creata in una delle regioni elencate in [Regione e gli endpoint](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in *Riferimenti generali di AWS*. Altrimenti, non sarà possibile utilizzare la coppia di chiavi con CodeDeploy.
## Avvia un'istanza Amazon EC2 con il CloudFormation modello (console)
1. Accedi Console di gestione AWS e apri la CloudFormation console all'indirizzo [https://console.aws.amazon.com/cloudformazione.](https://console.aws.amazon.com/cloudformation/)
**Importante**
Accedi a Console di gestione AWS con lo stesso account che hai utilizzato. [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md) Nella barra di navigazione, nel selettore della regione, scegli una delle regioni elencate in [Regione e terminali](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in. *Riferimenti generali di AWS* CodeDeploy supporta solo queste regioni.
1. Scegli **Crea stack**.
1. In **Scegli un modello**, scegli **Specificare l'URL di un modello Amazon S3**. Nella casella, digita la posizione del CloudFormation modello per la tua regione, quindi scegli **Avanti**.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/instances-ec2-create-cloudformation-template.html)
1. Nella casella **Stack name (Nome stack)** digitare il nome dello stack (ad esempio **CodeDeployDemoStack**).
1. In **Parameters (Parametri)**, digita quanto segue e scegli **Avanti**
+ Per **InstanceCount**, digita il numero di istanze che desideri avviare. (Ti consigliamo di lasciare l'impostazione predefinita di **1**).
+ Ad esempio **InstanceType**, digita il tipo di istanza che desideri avviare (o lascia il valore predefinito di **t1.micro**).
+ Per **KeyPairName**, digitare il nome della coppia di chiavi dell'istanza. Digita solo il nome della coppia di chiavi, non l'estensione del file della coppia di chiavi.
+ Per **OperatingSystem**box, digita **Windows** per avviare le istanze che eseguono Windows Server (o lascia l'impostazione predefinita di **Linux**).
+ **Per **SSHLocation**, digita l'intervallo di indirizzi IP da utilizzare per la connessione all'istanza con SSH o RDP (o lascia il valore predefinito 0.0.0.0/0).**
**Importante**
L'impostazione predefinita di viene fornita solo a scopo **0.0.0.0/0** dimostrativo. CodeDeploy non richiede che le istanze Amazon EC2 abbiano accesso illimitato alle porte. Come best practice, è consigliabile limitare l'accesso a porte SSH (e HTTP). Per ulteriori informazioni, consulta [Suggerimenti per proteggere l'istanza Amazon EC2](https://aws.amazon.com/articles/1233).
+ **Ad esempio **TagKey**, digita la chiave del tag dell'istanza CodeDeploy che utilizzerà per identificare le istanze durante la distribuzione (oppure lascia il valore predefinito di Name).**
+ Ad esempio **TagValue**, digita il valore del tag dell'istanza che CodeDeploy utilizzerà per identificare le istanze durante la distribuzione (o lascia il valore predefinito di **CodeDeployDemo**).
1. Nella pagina **Opzioni**, lasciare le caselle opzione vuote e scegliere **Successivo**.
**Importante**
CloudFormation i tag sono diversi dai CodeDeploy tag. CloudFormation utilizza i tag per semplificare l'amministrazione dell'infrastruttura. CodeDeploy utilizza tag per identificare le istanze Amazon EC2. I tag CodeDeploy specificati nella pagina **Specificare i parametri**.
1. **Nella pagina di **revisione**, in **Capacità**, seleziona la casella **Riconosco che CloudFormation potrebbe creare risorse IAM**, quindi scegli Crea.**
**Dopo CloudFormation aver creato lo stack e avviato le istanze Amazon EC2, nella CloudFormation console**,** CREATE\$1COMPLETE verrà visualizzato nella colonna Stato.** Questo processo può richiedere alcuni minuti.
Per verificare che l' CodeDeploy agente sia in esecuzione sulle istanze Amazon EC2[Gestione delle operazioni degli CodeDeploy agenti](codedeploy-agent-operations.md), consulta e procedi con. [Crea un'applicazione con CodeDeploy](applications-create.md)
## Avvia un'istanza Amazon EC2 con il CloudFormation modello ()AWS CLI
1. Usa il nostro CloudFormation modello in una chiamata al **create-stack** comando. Questo stack lancerà una nuova istanza Amazon EC2 con CodeDeploy l'agente installato.
Per avviare un'istanza Amazon EC2 che esegue Amazon Linux:
```
aws cloudformation create-stack \
--stack-name CodeDeployDemoStack \
--template-url templateURL \
--parameters ParameterKey=InstanceCount,ParameterValue=1 ParameterKey=InstanceType,ParameterValue=t1.micro \
ParameterKey=KeyPairName,ParameterValue=keyName ParameterKey=OperatingSystem,ParameterValue=Linux \
ParameterKey=SSHLocation,ParameterValue=0.0.0.0/0 ParameterKey=TagKey,ParameterValue=Name \
ParameterKey=TagValue,ParameterValue=CodeDeployDemo \
--capabilities CAPABILITY_IAM
```
Per avviare un'istanza Amazon EC2 che esegue Windows Server:
```
aws cloudformation create-stack --stack-name CodeDeployDemoStack --template-url template-url --parameters ParameterKey=InstanceCount,ParameterValue=1 ParameterKey=InstanceType,ParameterValue=t1.micro ParameterKey=KeyPairName,ParameterValue=keyName ParameterKey=OperatingSystem,ParameterValue=Windows ParameterKey=SSHLocation,ParameterValue=0.0.0.0/0 ParameterKey=TagKey,ParameterValue=Name ParameterKey=TagValue,ParameterValue=CodeDeployDemo --capabilities CAPABILITY_IAM
```
*keyName*è il nome della key pair dell'istanza. Digita solo il nome della coppia di chiavi, non l'estensione del file della coppia di chiavi.
*template-url*è la posizione del CloudFormation modello per la tua regione:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/instances-ec2-create-cloudformation-template.html)
Questo comando crea uno CloudFormation stack denominato**CodeDeployDemoStack**, utilizzando il CloudFormation modello nel bucket Amazon S3 specificato. L'istanza Amazon EC2 è basata sul tipo di istanza t1.micro, ma è possibile utilizzare qualsiasi tipo. Presenta un tag applicato con il valore **CodeDeployDemo**, ma è possibile applicare un tag con qualsiasi valore. Ha la coppia di chiavi di istanza specificata applicata.
1. Chiama il **describe-stacks** comando per verificare che lo CloudFormation stack denominato **CodeDeployDemoStack** sia stato creato correttamente:
```
aws cloudformation describe-stacks --stack-name CodeDeployDemoStack --query "Stacks[0].StackStatus" --output text
```
Non continuare finché il valore `CREATE_COMPLETE` non viene restituito.
Per verificare che l' CodeDeploy agente sia in esecuzione sull'istanza Amazon EC2[Gestione delle operazioni degli CodeDeploy agenti](codedeploy-agent-operations.md), consulta e procedi con. [Crea un'applicazione con CodeDeploy](applications-create.md)
# Configura un'istanza Amazon EC2 con cui lavorare CodeDeploy
Queste istruzioni mostrano come configurare un'istanza Amazon EC2 che esegue Amazon Linux, Ubuntu Server, Red Hat Enterprise Linux (RHEL) o Windows Server da utilizzare nelle distribuzioni. CodeDeploy
**Nota**
Se non disponi di un'istanza Amazon EC2, puoi utilizzare il CloudFormation modello per avviarne una che esegua Amazon Linux o Windows Server. Non forniamo un modello per Ubuntu Server o RHEL.
## Fase 1: verifica che un profilo di istanza IAM sia collegato alla tua istanza Amazon EC2
1. Accedi Console di gestione AWS e apri la console Amazon EC2 all'indirizzo. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Nel riquadro di navigazione, in **Istanze** scegli **Istanze**.
1. Cerca e scegli la tua istanza Amazon EC2 nell'elenco.
1. Nel riquadro dei dettagli, nella scheda **Descrizione**, annota il valore nel campo del **ruolo IAM**, quindi passa alla sezione successiva.
Se il campo è vuoto, puoi allegare un profilo di istanza IAM all'istanza. Per informazioni, consulta [Associare un ruolo IAM a un'istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role).
## Passaggio 2: verifica che il profilo dell'istanza IAM collegato disponga delle autorizzazioni di accesso corrette
1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nel riquadro di navigazione, seleziona **Ruoli**.
1. Naviga e scegli il nome del ruolo IAM che hai annotato nel passaggio 4 della sezione precedente.
**Nota**
Se desideri utilizzare il ruolo di servizio generato dal CloudFormation modello anziché uno creato seguendo le istruzioni riportate in[Fase 2: Creare un ruolo di servizio per CodeDeploy](getting-started-create-service-role.md), tieni presente quanto segue:
In alcune versioni del nostro CloudFormation modello, il nome visualizzato del profilo dell'istanza IAM generato e collegato alle istanze Amazon EC2 non è lo stesso del nome visualizzato nella console IAM. Ad esempio, il profilo dell'istanza IAM potrebbe avere un nome visualizzato di`CodeDeploySampleStack-expnyi6-InstanceRoleInstanceProfile-IK8J8A9123EX`, mentre il profilo dell'istanza IAM nella console IAM potrebbe avere un nome visualizzato di. `CodeDeploySampleStack-expnyi6-InstanceRole-C5P33V1L64EX`
Per aiutarti a identificare il profilo dell'istanza nella console IAM, vedrai che il prefisso di `CodeDeploySampleStack-expnyi6-InstanceRole` è lo stesso per entrambi. Per informazioni sul motivo per cui questi nomi visualizzati potrebbero essere diversi, consulta [Profili di istanza](https://docs.aws.amazon.com/IAM/latest/UserGuide/instance-profiles.html).
1. Scegli la scheda **Relazioni di attendibilità**. Se non è presente alcuna voce in **Trusted Entities** che riporta **The identity provider (s) ec2.amazonaws.com**, non puoi utilizzare questa istanza Amazon EC2. Interrompi e crea un'istanza Amazon EC2 utilizzando le informazioni contenute in. [Utilizzo delle istanze per CodeDeploy](instances.md)
Se c'è una voce che dice **The identity provider (s) ec2.amazonaws.com** e stai archiviando le tue applicazioni solo in GitHub repository, passa direttamente a. [Fase 3: etichettare l'istanza Amazon EC2](#instances-ec2-configure-3-tag-instance)
**Se è presente una voce che dice **The identity provider (s) ec2.amazonaws.com** e stai archiviando le tue applicazioni in bucket Amazon S3, scegli la scheda Autorizzazioni.**
1. Se è presente una policy nell'area **Policy di autorizzazioni**, scegliere il nome della policy e quindi selezionare **Modifica policy**.
1. Scegli la scheda **JSON**. Se stai archiviando le tue applicazioni in bucket Amazon S3, assicurati `"s3:Get*"` di essere nell'elenco delle azioni `"s3:List*"` specificate.
Potrebbe essere simile a quanto segue:
```
{"Statement":[{"Resource":"*","Action":[
... Some actions may already be listed here ...
"s3:Get*","s3:List*"
... Some more actions may already be listed here ...
],"Effect":"Allow"}]}
```
O potrebbe essere simile a quanto segue:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:Get*",
"s3:List*"
],
"Resource": "*"
}
]
}
```
------
Se `"s3:Get*"` e non `"s3:List*"` sono nell'elenco di azioni specificate, scegliere **Edit (Modifica)** per aggiungerli, quindi scegliere **Save (Salva)**. (Se né `"s3:Get*"` né `"s3:List*"` sono l'ultima operazione nell'elenco, assicurarsi di aggiungere una virgola dopo l'operazione, in modo da convalidare il documento della policy.)
**Nota**
Ti consigliamo di limitare questa politica solo ai bucket Amazon S3 a cui devono accedere le tue istanze Amazon EC2. Assicurati di consentire l'accesso ai bucket Amazon S3 che contengono l'agente. CodeDeploy In caso contrario, potrebbe verificarsi un errore quando l' CodeDeploy agente viene installato o aggiornato sulle istanze. Per concedere al profilo dell'istanza IAM l'accesso solo ad alcuni bucket del kit di CodeDeploy risorse in Amazon S3, utilizza la seguente policy, ma rimuovi le righe relative ai bucket a cui desideri impedire l'accesso:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:Get*",
"s3:List*"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::aws-codedeploy-us-east-2/*",
"arn:aws:s3:::aws-codedeploy-us-east-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-2/*",
"arn:aws:s3:::aws-codedeploy-ca-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-2/*",
"arn:aws:s3:::aws-codedeploy-eu-west-3/*",
"arn:aws:s3:::aws-codedeploy-eu-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-central-2/*",
"arn:aws:s3:::aws-codedeploy-eu-north-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-2/*",
"arn:aws:s3:::aws-codedeploy-il-central-1/*",
"arn:aws:s3:::aws-codedeploy-ap-east-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-4/*",
"arn:aws:s3:::aws-codedeploy-ap-south-1/*",
"arn:aws:s3:::aws-codedeploy-ap-south-2/*",
"arn:aws:s3:::aws-codedeploy-me-central-1/*",
"arn:aws:s3:::aws-codedeploy-me-south-1/*",
"arn:aws:s3:::aws-codedeploy-sa-east-1/*"
]
}
]
}
```
## Fase 3: etichettare l'istanza Amazon EC2
Per istruzioni su come etichettare l'istanza Amazon EC2 in modo che CodeDeploy possa trovarla durante una distribuzione, consulta [Lavorare con i tag nella console](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#Using_Tags_Console), quindi torna a questa pagina.
**Nota**
Puoi etichettare l'istanza Amazon EC2 con qualsiasi chiave e valore desideri. Assicurarsi solo di specificare la chiave e il valore quando si distribuisce.
## Fase 4: installare l' AWS CodeDeploy agente sull'istanza Amazon EC2
Per istruzioni su come installare l' CodeDeploy agente sull'istanza Amazon EC2 e verificare che sia in esecuzione[Gestione delle operazioni degli CodeDeploy agenti](codedeploy-agent-operations.md), consulta e procedi a. [Crea un'applicazione con CodeDeploy](applications-create.md)
# Utilizzo di istanze locali per CodeDeploy
Un'istanza locale è qualsiasi dispositivo fisico diverso da un'istanza Amazon EC2 in grado di eseguire CodeDeploy l'agente e connettersi agli endpoint del AWS servizio pubblico.
La distribuzione di una revisione CodeDeploy dell'applicazione su un'istanza locale prevede due passaggi principali:
+ **Passaggio 1**: configurare ogni istanza locale, registrarla e quindi CodeDeploy etichettarla.
+ **Passaggio 2**: distribuisci le revisioni dell'applicazione nell'istanza locale.
**Nota**
Per provare a creare e a distribuire una revisione di un'applicazione di esempio a un'istanza locale configurata e registrata correttamente, consulta [Tutorial: Implementa un'applicazione su un'istanza locale con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)](tutorials-on-premises-instance.md). Per informazioni sulle istanze locali e su come funzionano, consulta. CodeDeploy [Utilizzo di istanze locali per CodeDeploy](#instances-on-premises)
Se non desideri più utilizzare un'istanza locale nelle distribuzioni, puoi rimuovere i tag delle istanze locali dai gruppi di distribuzione. In alternativa, puoi rimuovere i tag di istanza locale dall'istanza. O ancora, puoi annullare in modo esplicito la registrazione di un'istanza locale in modo che non possa più essere utilizzata in nessuna distribuzione. Per ulteriori informazioni, consulta [Gestione delle operazioni delle istanze locali in CodeDeploy](on-premises-instances-operations.md).
Le istruzioni in questa sezione mostrano come configurare un'istanza locale, quindi registrarla e contrassegnarla in CodeDeploy modo che possa essere utilizzata nelle distribuzioni. Questa sezione descrive anche come utilizzare per CodeDeploy ottenere informazioni sulle istanze locali e annullare la registrazione di un'istanza locale dopo che non si prevede più di distribuirla.
**Topics**
+ [Prerequisiti per la configurazione di un'istanza locale](instances-on-premises-prerequisites.md)
+ [Registrare un'istanza locale](on-premises-instances-register.md)
+ [Gestione delle operazioni sulle istanze locali](on-premises-instances-operations.md)
# Prerequisiti per la configurazione di un'istanza locale
È necessario soddisfare i seguenti prerequisiti prima di poter annullare la registrazione di un'istanza locale.
**Importante**
Se utilizzi il [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)comando e aggiorni periodicamente le credenziali temporanee generate con AWS Security Token Service (AWS STS), esistono altri prerequisiti. Per informazioni, consulta [Prerequisiti per la registrazione ARN della sessione IAM](register-on-premises-instance-iam-session-arn.md#register-on-premises-instance-iam-session-arn-prerequisites).
**Requisiti per il dispositivo**
Il dispositivo che desideri preparare, registrare ed etichettare come istanza locale CodeDeploy deve eseguire un sistema operativo supportato. Per un elenco, consulta [Sistemi operativi supportati dall'agente CodeDeploy](codedeploy-agent.md#codedeploy-agent-supported-operating-systems).
Se il tuo sistema operativo non è supportato, l' CodeDeploy agente è disponibile come open source per adattarlo alle tue esigenze. Per ulteriori informazioni, consulta il repository degli [CodeDeploy agenti](https://github.com/aws/aws-codedeploy-agent) in GitHub.
**Comunicazione in uscita**
L'istanza locale deve essere in grado di connettersi agli endpoint del AWS servizio pubblico con cui comunicare. CodeDeploy
L' CodeDeploy agente comunica in uscita utilizzando HTTPS sulla porta 443.
**Controllo amministrativo**
L'account locale o di rete utilizzato nell'istanza locale per configurare l'istanza locale deve poter essere eseguito come o `root` (per Ubuntu Server) `sudo` o come amministratore (per Windows Server).
**Autorizzazioni IAM**
All'identità IAM utilizzata per registrare l'istanza locale devono essere concesse le autorizzazioni per completare la registrazione (e per annullare la registrazione dell'istanza locale, se necessario).
Oltre alla policy descritta in[Passaggio 3: Limita le autorizzazioni CodeDeploy dell'utente](getting-started-policy.md), assicurati che all'identità IAM chiamante sia allegata la seguente policy aggiuntiva.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:CreateAccessKey",
"iam:CreateUser",
"iam:DeleteAccessKey",
"iam:DeleteUser",
"iam:DeleteUserPolicy",
"iam:ListAccessKeys",
"iam:ListUserPolicies",
"iam:PutUserPolicy",
"iam:GetUser"
],
"Resource": "*"
}
]
}
```
------
Per informazioni su come collegare le policy IAM, consulta [Gestione di policy IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html).
# Registra un'istanza locale con CodeDeploy
Per eseguire la registrazione di un'istanza locale, devi utilizzare un'identità IAM per autenticare le richieste. Puoi scegliere tra le seguenti opzioni per l'identità IAM e il metodo di registrazione che utilizzi:
+ Utilizzo di un ARN ruolo IAM per autenticare le richieste.
+ Utilizza il [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)comando e le credenziali temporanee aggiornate periodicamente generate con AWS Security Token Service (AWS STS) per configurare manualmente la maggior parte delle opzioni di registrazione. Questa opzione offre il massimo livello di sicurezza, poiché l'autenticazione avviene utilizzando un token temporaneo che scade e deve essere aggiornato periodicamente. Questa opzione è consigliata per implementazioni di produzione di qualsiasi dimensione. Per informazioni, consulta [Usa il register-on-premises-instance comando (IAM Session ARN) per registrare un'istanza locale](register-on-premises-instance-iam-session-arn.md).
+ (Non consigliato) Utilizza un ARN utente IAM per autenticare le richieste.
+ Utilizza il comando [register](https://docs.aws.amazon.com/cli/latest/reference/deploy/register.html) per il processo di registrazione più automatizzato. Questa opzione dovrebbe essere utilizzata solo per le implementazioni non di produzione in cui la sicurezza è meno importante. Questa opzione è meno sicura perché utilizza credenziali statiche (permanenti) per l'autenticazione. Questa opzione è ideale per registrare una singola istanza locale. Per informazioni, consulta [Usa il comando register (ARN dell'utente IAM) per registrare un'istanza locale](instances-on-premises-register-instance.md).
+ Utilizza il comando [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html) per configurare manualmente la maggior parte delle opzioni di registrazione. È un'opzione indicata per la registrazione di un piccolo numero di istanze locali. Per informazioni, consulta [Usa il register-on-premises-instance comando (utente IAM ARN) per registrare un'istanza locale](register-on-premises-instance-iam-user-arn.md).
**Topics**
+ [Usa il register-on-premises-instance comando (IAM Session ARN) per registrare un'istanza locale](register-on-premises-instance-iam-session-arn.md)
+ [Usa il comando register (ARN dell'utente IAM) per registrare un'istanza locale](instances-on-premises-register-instance.md)
+ [Usa il register-on-premises-instance comando (utente IAM ARN) per registrare un'istanza locale](register-on-premises-instance-iam-user-arn.md)
# Usa il register-on-premises-instance comando (IAM Session ARN) per registrare un'istanza locale
Per il massimo controllo sull'autenticazione e la registrazione delle istanze locali, puoi utilizzare il [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)comando e le credenziali temporanee aggiornate periodicamente generate con (). AWS Security Token Service AWS STS Un ruolo IAM statico per l'istanza assume il ruolo di queste credenziali aggiornate per eseguire operazioni di distribuzione. AWS STS CodeDeploy
Questo metodo è molto utile quando è necessario registrare un numero elevato di istanze, Consente di automatizzare il processo di registrazione con. CodeDeploy È possibile utilizzare il proprio sistema di identità e autenticazione per autenticare le istanze locali e distribuire le credenziali di sessione IAM dal servizio alle istanze con cui utilizzarle. CodeDeploy
**Nota**
In alternativa, puoi utilizzare un utente IAM condiviso distribuito su tutte le istanze locali per chiamare l' AWS STS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API e recuperare le credenziali di sessione per le istanze locali. Questo metodo è meno sicuro e non è consigliato per ambienti di produzione o mission-critical.
Utilizza le informazioni contenute nei seguenti argomenti per configurare un'istanza locale utilizzando credenziali di sicurezza temporanee generate con. AWS STS
**Topics**
+ [Prerequisiti per la registrazione ARN della sessione IAM](#register-on-premises-instance-iam-session-arn-prerequisites)
+ [Fase 1: Creare il ruolo IAM che le istanze locali assumeranno](#register-on-premises-instance-iam-session-arn-1)
+ [Passaggio 2: generare credenziali temporanee per una singola istanza utilizzando AWS STS](#register-on-premises-instance-iam-session-arn-2)
+ [Passaggio 3: aggiungere un file di configurazione all'istanza locale](#register-on-premises-instance-iam-session-arn-3)
+ [Fase 4: Preparare un'istanza locale per le distribuzioni CodeDeploy](#register-on-premises-instance-iam-session-arn-4)
+ [Passaggio 5: registrare l'istanza locale con CodeDeploy](#register-on-premises-instance-iam-session-arn-5)
+ [Passaggio 6: assegna un tag all'istanza locale](#register-on-premises-instance-iam-session-arn-6)
+ [Passaggio 7: distribuisci le revisioni dell'applicazione nell'istanza locale](#register-on-premises-instance-iam-session-arn-7)
+ [Fase 8: Tieni traccia delle distribuzioni sull'istanza locale](#register-on-premises-instance-iam-session-arn-8)
## Prerequisiti per la registrazione ARN della sessione IAM
Oltre ai prerequisiti elencati in [Prerequisiti per la configurazione di un'istanza locale](instances-on-premises-prerequisites.md), devono essere soddisfatti i seguenti requisiti aggiuntivi:
**Autorizzazioni IAM**
All'identità IAM utilizzata per registrare un'istanza locale devono essere concesse le autorizzazioni per eseguire operazioni. CodeDeploy Accertarti che la policy gestita **AWSCodeDeployFullAccess** sia collegata all'identità IAM. Per informazioni, consulta le [policy AWS gestite nella Guida](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) per l'*utente IAM*.
**Sistema per aggiornare credenziali temporanee**
Se utilizzi un ARN della sessione IAM per registrare istanze locali, è necessario disporre di un sistema per aggiornare periodicamente le credenziali temporanee. Le credenziali temporanee scadono dopo un'ora o prima se viene specificato un periodo di tempo più breve quando le credenziali vengono generate. Sono disponibili due metodi per aggiornare le credenziali:
+ **Metodo 1**: utilizzare il sistema di identità e autenticazione operante nella rete aziendale con uno script CRON che effettua periodicamente il polling del sistema di identità e autenticazione e che copia le credenziali di sessione più recenti nell'istanza. Ciò consente di integrare la struttura di autenticazione e identità AWS senza dover apportare modifiche all' CodeDeploy agente o al servizio per supportare i tipi di autenticazione utilizzati nell'organizzazione.
+ **Metodo 2**: esegui periodicamente un processo CRON sull'istanza per richiamare l' AWS STS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)azione e scrivere le credenziali della sessione in un file a cui l' CodeDeploy agente può accedere. Questo metodo richiede ancora l'utilizzo di un utente IAM e la copia delle credenziali nell'istanza locale, ma è possibile riutilizzare lo stesso utente e le stesse credenziali IAM all'interno del parco istanze locali.
**Nota**
Indipendentemente dal fatto che si utilizzi il metodo 1 o 2, è necessario impostare un processo per riavviare l' CodeDeploy agente dopo l'aggiornamento delle credenziali della sessione temporanea in modo che le nuove credenziali abbiano effetto.
Per informazioni sulla creazione e l'utilizzo AWS STS delle credenziali, consulta [AWS Security Token Service API Reference](https://docs.aws.amazon.com/STS/latest/APIReference/) e [Utilizzo delle credenziali di sicurezza temporanee per richiedere l'accesso alle risorse](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html). AWS
## Fase 1: Creare il ruolo IAM che le istanze locali assumeranno
Puoi utilizzare la console IAM AWS CLI o la console IAM per creare un ruolo IAM che verrà utilizzato dalle istanze locali per l'autenticazione e l'interazione. CodeDeploy
È sufficiente creare un singolo ruolo IAM. Ognuna delle istanze locali può assumere questo ruolo per recuperare le credenziali di sicurezza temporanee che forniscono le autorizzazioni concesse a questo ruolo.
Il ruolo che crei richiederà le seguenti autorizzazioni per accedere ai file necessari per installare l'agente: CodeDeploy
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
Ti consigliamo di limitare questa politica solo ai bucket Amazon S3 a cui deve accedere l'istanza locale. Se limiti questa politica, assicurati di consentire l'accesso ai bucket Amazon S3 che contengono l'agente. CodeDeploy In caso contrario, potrebbe verificarsi un errore ogni volta che l' CodeDeploy agente viene installato o aggiornato sull'istanza locale. Per informazioni sul controllo dell'accesso ai bucket Amazon S3, consulta [Gestione delle autorizzazioni di accesso alle risorse Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-access-control.html).
**Per creare il ruolo IAM**
1. Chiamare il comando [create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html) utilizzando l'opzione `--role-name` per specificare un nome per il ruolo IAM (ad esempio, `CodeDeployInstanceRole`) e l'opzione `--assume-role-policy-document` per fornire le autorizzazioni.
Quando si crea il ruolo IAM per questa istanza, è possibile denominarlo `CodeDeployInstanceRole` e includere le autorizzazioni richieste in un file denominato `CodeDeployRolePolicy.json`:
```
aws iam create-role --role-name CodeDeployInstanceRole --assume-role-policy-document file://CodeDeployRolePolicy.json
```
1. Nell'output della chiamata al comando **create-role**, prendere nota del valore del campo ARN. Esempio:
```
arn:aws:iam::123456789012:role/CodeDeployInstanceRole
```
Avrai bisogno del ruolo ARN quando utilizzi l' AWS STS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API per generare credenziali a breve termine per ogni istanza.
*Per ulteriori informazioni sulla creazione di ruoli IAM, consulta [Creazione di un ruolo per delegare le autorizzazioni a un AWS servizio nella Guida per l'utente](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) IAM.*
[Per informazioni sull'assegnazione delle autorizzazioni a un ruolo esistente, consulta [put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html)Command Reference.AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/)
## Passaggio 2: generare credenziali temporanee per una singola istanza utilizzando AWS STS
Prima di generare le credenziali temporanee che verranno utilizzate per registrare un'istanza locale, occorre creare o scegliere l'identità IAM (utente o ruolo) per la quale le credenziali temporanee verranno generate. L'autorizzazione `sts:AssumeRole` deve essere inclusa nelle impostazioni della policy per questa identità IAM.
Per informazioni sulla concessione `sts:AssumeRole` delle autorizzazioni a un'identità IAM, consulta [Creazione di un ruolo per delegare le autorizzazioni a](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) un servizio e. AWS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)
Sono disponibili due modi per generare le credenziali temporanee:
+ Usa il comando [assume-role](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html) con. AWS CLI Esempio:
```
aws sts assume-role --role-arn arn:aws:iam::12345ACCOUNT:role/role-arn --role-session-name session-name
```
Dove:
+ *12345ACCOUNT*è il numero di conto a 12 cifre dell'organizzazione.
+ *role-arn*è l'ARN del ruolo da assumere, in cui è stato generato. [Fase 1: Creare il ruolo IAM che le istanze locali assumeranno](#register-on-premises-instance-iam-session-arn-1)
+ *session-name*è il nome che si desidera assegnare alla sessione di ruolo che si sta creando ora.
**Nota**
Se utilizzi uno script CRON che esegue periodicamente il polling del sistema di identità e autenticazione e copia le credenziali di sessione più recenti sull'istanza (metodo 1 per l'aggiornamento delle credenziali temporanee descritto in[Prerequisiti per la registrazione ARN della sessione IAM](#register-on-premises-instance-iam-session-arn-prerequisites)), puoi invece utilizzare qualsiasi SDK supportato per la chiamata. AWS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)
+ Utilizza uno strumento fornito da. AWS
Lo aws-codedeploy-session-helper strumento genera AWS STS credenziali e le scrive in un file inserito nell'istanza. Questo strumento è il più appropriato per il metodo 2 per aggiornare le credenziali temporanee descritte in [Prerequisiti per la registrazione ARN della sessione IAM](#register-on-premises-instance-iam-session-arn-prerequisites). In questo metodo, lo aws-codedeploy-session-helper strumento viene posizionato su ogni istanza ed esegue il comando utilizzando le autorizzazioni di un utente IAM. Ogni istanza utilizza le stesse credenziali dell'utente IAM in combinazione con questo strumento.
Per ulteriori informazioni, consulta il [aws-codedeploy-session-helper](https://github.com/awslabs/aws-codedeploy-samples/tree/master/utilities/aws-codedeploy-session-helper) GitHub repository.
**Nota**
Dopo aver creato le credenziali della sessione IAM, posizionarle in qualsiasi posizione dell'istanza locale. Nel passaggio successivo, configurerai l' CodeDeploy agente per accedere alle credenziali in questa posizione.
Prima di continuare, assicurati che il sistema utilizzato per aggiornare periodicamente le credenziali temporanee sia disponibile. Se le credenziali temporanee non vengono aggiornate, le distribuzioni all'istanza locale non vanno a buon fine. Per ulteriori informazioni, consulta "Sistema per aggiornare le credenziali temporanee" in [Prerequisiti per la registrazione ARN della sessione IAM](#register-on-premises-instance-iam-session-arn-prerequisites).
## Passaggio 3: aggiungere un file di configurazione all'istanza locale
Aggiungi un file di configurazione all'istanza locale, utilizzando le autorizzazioni dell'utente root o amministratore. Questo file di configurazione viene utilizzato per dichiarare le credenziali IAM e la AWS regione di destinazione per cui utilizzare. CodeDeploy Il file deve essere aggiunto in una posizione specifica dell'istanza locale. Il file deve includere l'ARN della sessione temporanea IAM, l'ID della chiave segreta e la chiave di accesso segreta e la regione di destinazione AWS .
**Per aggiungere un file di configurazione**
1. Crea un file denominato `codedeploy.onpremises.yml` (per un'istanza locale di Ubuntu Server o RHEL) o `conf.onpremises.yml` (per un'istanza locale di Windows Server) nella seguente posizione sull'istanza locale:
+ Per Ubuntu Server: `/etc/codedeploy-agent/conf`
+ Per Windows Server: `C:\ProgramData\Amazon\CodeDeploy`
1. Utilizzate un editor di testo per aggiungere le seguenti informazioni al `codedeploy.onpremises.yml` file (Linux) o al `conf.onpremises.yml` file (Windows) appena creato:
```
---
iam_session_arn: iam-session-arn
aws_credentials_file: credentials-file
region: supported-region
```
Dove:
+ *iam-session-arn*è l'ARN della sessione IAM in cui hai annotato. [Passaggio 2: generare credenziali temporanee per una singola istanza utilizzando AWS STS](#register-on-premises-instance-iam-session-arn-2)
+ *credentials-file*è la posizione del file delle credenziali per l'ARN della sessione temporanea, come indicato in. [Passaggio 2: generare credenziali temporanee per una singola istanza utilizzando AWS STS](#register-on-premises-instance-iam-session-arn-2)
+ *supported-region*è una delle regioni che CodeDeploy supporta, come indicato in [Regione ed endpoint](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in. *Riferimenti generali di AWS*
## Fase 4: Preparare un'istanza locale per le distribuzioni CodeDeploy
**Installa e configura il AWS CLI **
Installa e configura AWS CLI l'istanza locale. ( AWS CLI Verrà utilizzato per scaricare e installare l' CodeDeploy agente sull'istanza locale.)
1. Per installare l' AWS CLI istanza locale, segui le istruzioni riportate nella [Guida](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html) per l'utente AWS CLI nella Guida per l'*AWS Command Line Interface utente*.
**Nota**
CodeDeploy i comandi per lavorare con le istanze locali sono diventati disponibili nella versione 1.7.19 di. AWS CLI Se hai una versione di quella AWS CLI già installata, puoi verificarne la versione chiamando. **aws --version**
1. Per configurare l' AWS CLI istanza locale, segui le istruzioni in [Configurazione della istanza locale nella Guida AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) per l'*AWS Command Line Interface utente*.
**Importante**
Durante la configurazione AWS CLI (ad esempio, chiamando il **aws configure** comando), assicurati di specificare l'ID della chiave segreta e la chiave di accesso segreta di un utente IAM che disponga almeno delle autorizzazioni descritte in. [Prerequisiti per la registrazione ARN della sessione IAM](#register-on-premises-instance-iam-session-arn-prerequisites)
**Imposta la variabile di AWS\$1REGION ambiente (solo Ubuntu Server e RHEL)**
Se non utilizzi Ubuntu Server o RHEL sulla tua istanza locale, salta questo passaggio e vai direttamente a «Installa l'agente». CodeDeploy
Installa l' CodeDeploy agente su un'istanza locale di Ubuntu Server o RHEL e abilita l'istanza ad aggiornare l' CodeDeploy agente ogni volta che diventa disponibile una nuova versione. A questo scopo, imposta la variabile di ambiente `AWS_REGION` nell'istanza sull'identificatore di una delle regioni supportate da CodeDeploy. Si consiglia di impostare il valore sulla regione in cui si trovano CodeDeploy le applicazioni, i gruppi di distribuzione e le revisioni delle applicazioni (ad esempio,). `us-west-2` Per un elenco delle regioni, consulta [Regione ed endpoint](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in. *Riferimenti generali di AWS*
Per impostare la variabile di ambiente, esegui la chiamata seguente dal terminale:
```
export AWS_REGION=supported-region
```
*supported-region*Dov'è l'identificatore della regione (ad esempio,`us-west-2`).
**Installa l'agente CodeDeploy **
+ Per un'istanza locale di Ubuntu Server, segui le istruzioni riportate in[Installa l' CodeDeploy agente per Ubuntu Server](codedeploy-agent-operations-install-ubuntu.md), quindi torna a questa pagina.
+ Per un'istanza RHEL locale, segui le istruzioni riportate in[Installa l' CodeDeploy agente per Amazon Linux o RHEL](codedeploy-agent-operations-install-linux.md), quindi torna a questa pagina.
+ Per un'istanza locale di Windows Server, segui le istruzioni riportate e torna a questa pagina. [Installa l' CodeDeploy agente per Windows Server](codedeploy-agent-operations-install-windows.md)
## Passaggio 5: registrare l'istanza locale con CodeDeploy
Le istruzioni in questa fase presumono che la registrazione dell'istanza locale venga eseguita dall'istanza locale stessa. È possibile registrare un'istanza locale da un dispositivo o un'istanza separato su cui è AWS CLI installata e configurata.
Utilizza il AWS CLI per registrare l'istanza locale CodeDeploy in modo che possa essere utilizzata nelle distribuzioni.
Prima di poter utilizzare AWS CLI, è necessario l'ARN delle credenziali di sessione temporanea in cui sono state create. [Passaggio 3: aggiungere un file di configurazione all'istanza locale](#register-on-premises-instance-iam-session-arn-3) Ad esempio, per un'istanza identificata come `AssetTag12010298EX`:
```
arn:sts:iam::123456789012:assumed-role/CodeDeployInstanceRole/AssetTag12010298EX
```
Chiama il comando [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html), specificando:
+ Un nome che identifica in modo univoco l'istanza locale (con l'opzione `--instance-name`).
**Importante**
Per identificare più facilmente l'istanza locale, soprattutto per scopi di debug, ti consigliamo di specificare un nome mappato ad alcune caratteristiche univoche dell'istanza locale (ad esempio, session-name delle credenziali STS e il numero di serie o un identificatore di asset interno, se applicabile). Se specificate un indirizzo MAC come nome, tenete presente che gli indirizzi MAC contengono caratteri CodeDeploy non consentiti, come i due punti (:). Per un elenco dei caratteri consentiti, consulta [CodeDeploy quote](limits.md).
+ L'ARN della sessione IAM impostata per autenticare più istanze locali in [Fase 1: Creare il ruolo IAM che le istanze locali assumeranno](#register-on-premises-instance-iam-session-arn-1).
Esempio:
```
aws deploy register-on-premises-instance --instance-name name-of-instance --iam-session-arn arn:aws:sts::account-id:assumed-role/role-to-assume/session-name
```
Dove:
+ *name-of-instance*è il nome che usi per identificare l'istanza locale, ad esempio. `AssetTag12010298EX`
+ *account-id*è l'ID dell'account a 12 cifre dell'organizzazione, ad esempio. `111222333444`
+ *role-to-assume*è il nome del ruolo IAM che hai creato per l'istanza, ad esempio. `CodeDeployInstanceRole`
+ *session-name*è il nome del ruolo di sessione in cui hai specificato[Passaggio 2: generare credenziali temporanee per una singola istanza utilizzando AWS STS](#register-on-premises-instance-iam-session-arn-2).
## Passaggio 6: assegna un tag all'istanza locale
Puoi utilizzare la AWS CLI o la CodeDeploy console per etichettare l'istanza locale. (CodeDeployutilizza i tag delle istanze locali per identificare gli obiettivi di distribuzione durante una distribuzione.)
**Per applicare tag all'istanza locale (CLI)**
+ Chiama il comando [add-tags-to-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/add-tags-to-on-premises-instances.html), specificando:
+ Il nome che identifica in modo univoco l'istanza locale (con l'opzione `--instance-names`).
+ Il nome della chiave tag e del valore tag dell'istanza locale che si desidera utilizzare (con l'opzione `--tags`). È necessario specificare sia un nome che un valore. CodeDeploy non consente tag di istanza locali con solo valori.
Esempio:
```
aws deploy add-tags-to-on-premises-instances --instance-names AssetTag12010298EX --tags Key=Name,Value=CodeDeployDemo-OnPrem
```
**Per applicare tag all'istanza locale (console)**
1. Accedi Console di gestione AWS e apri la CodeDeploy console all'indirizzo [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
**Nota**
Accedi con lo stesso utente che hai configurato. [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md)
1. Nel riquadro di navigazione, espandi **Deploy** e scegli Istanze **locali**.
1. Nell'elenco delle istanze locali, scegliere il nome dell'istanza locale a cui desideri applicare tag.
1. Nell'elenco di tag, selezionare o immettere la chiave tag e il valore tag desiderati. Dopo aver immesso la chiave tag e il valore tag, viene visualizzata un'altra riga. È possibile ripetere questa operazione fino a 10 tag. Per rimuovere un tag, scegli **Remove** (Rimuovi).
1. Dopo aver aggiunto i tag, scegliere **Update Tags (Aggiorna tag)**.
## Passaggio 7: distribuisci le revisioni dell'applicazione nell'istanza locale
È ora possibile distribuire le revisioni dell'applicazione all'istanza locale registrata e contrassegnata.
Distribuisci le revisioni delle applicazioni sulle istanze locali in un modo simile alla distribuzione delle revisioni delle applicazioni sulle istanze Amazon EC2. Per istruzioni, consulta [Crea una distribuzione con CodeDeploy](deployments-create.md). Queste istruzioni includono un link ai prerequisiti, inclusa la creazione di un'applicazione, la creazione di un gruppo di distribuzione e la preparazione di una revisione dell'applicazione. Se occorre una semplice revisione dell'applicazione di esempio da distribuire, puoi creare quella descritta in [Passaggio 2: creare una revisione di esempio dell'applicazione](tutorials-on-premises-instance-2-create-sample-revision.md) nel [Tutorial: Implementa un'applicazione su un'istanza locale con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)](tutorials-on-premises-instance.md).
**Importante**
Se riutilizzi un ruolo di CodeDeploy servizio come parte della creazione di un gruppo di distribuzione destinato alle istanze locali, devi includere `Tag:get*` nella parte della politica del ruolo di servizio. `Action` Per ulteriori informazioni, consulta [Fase 2: Creare un ruolo di servizio per CodeDeploy](getting-started-create-service-role.md).
## Fase 8: Tieni traccia delle distribuzioni sull'istanza locale
Dopo aver distribuito una revisione dell'applicazione a istanze locali registrate e contrassegnate, puoi monitorare l'avanzamento della distribuzione.
Tieni traccia delle distribuzioni su istanze locali in modo simile al monitoraggio delle distribuzioni su istanze Amazon EC2. Per istruzioni, consulta [Visualizza i dettagli CodeDeploy della distribuzione](deployments-view-details.md).
# Usa il comando register (ARN dell'utente IAM) per registrare un'istanza locale
**Importante**
La registrazione di un'istanza utilizzando un utente IAM non è consigliata perché utilizza credenziali statiche (permanenti) per l'autenticazione. Per una maggiore sicurezza, consigliamo di registrare un'istanza utilizzando credenziali temporanee per l'autenticazione. Per ulteriori informazioni, consulta [Usa il register-on-premises-instance comando (IAM Session ARN) per registrare un'istanza locale](register-on-premises-instance-iam-session-arn.md).
**Importante**
Assicurati di disporre di un piano per la rotazione delle chiavi di accesso dell'utente IAM (credenziali permanenti). Per ulteriori informazioni, consulta [Rotazione](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_credentials_access-keys.html#Using_RotateAccessKey) delle chiavi di accesso.
Questa sezione descrive come configurare, registrare e applicare tag a un'istanza locale con il minimo sforzo utilizzando CodeDeploy . Il comando **register** è particolarmente utile quando si utilizza una singola istanza locale o un parco di istanze locali di piccole dimensioni. È possibile utilizzare il **register** comando solo quando si utilizza l'ARN di un utente IAM per autenticare un'istanza. Non è possibile utilizzare il **register** comando con un ARN di sessione IAM per l'autenticazione.
Quando usi il **register** comando, puoi CodeDeploy fare quanto segue:
+ Crea un utente IAM AWS Identity and Access Management per l'istanza locale, se non ne specifichi uno con il comando.
+ Salva le credenziali dell'utente IAM in un file di configurazione dell'istanza locale.
+ Registra l'istanza locale con. CodeDeploy
+ Aggiungere tag all'istanza locale, se li specifichi come parte del comando.
**Nota**
Il [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)comando è un'alternativa al comando [register](https://docs.aws.amazon.com/cli/latest/reference/deploy/register.html). Il comando **register-on-premises-instance** è indicato se desideri configurare, registrare e aggiungere tag a un'istanza locale con CodeDeploy per la maggior parte in modo autonomo. Il **register-on-premises-instance** comando offre anche la possibilità di utilizzare un ARN di sessione IAM per registrare le istanze anziché un ARN utente IAM. Questo approccio offre un vantaggio notevole se disponi di parchi di istanze locali di grandi dimensioni. In particolare, puoi utilizzare una singola sessione ARN di IAM per autenticare più istanze invece di dover creare un utente IAM per ogni istanza locale una per una. Per ulteriori informazioni, consultare [Usa il register-on-premises-instance comando (utente IAM ARN) per registrare un'istanza locale](register-on-premises-instance-iam-user-arn.md) e [Usa il register-on-premises-instance comando (IAM Session ARN) per registrare un'istanza locale](register-on-premises-instance-iam-session-arn.md).
**Topics**
+ [Passaggio 1: installa e configura l'istanza locale AWS CLI](#instances-on-premises-register-instance-1-install-cli)
+ [Passaggio 2: chiama il comando register](#instances-on-premises-register-instance-2-register-command)
+ [Passaggio 3: richiama il comando di installazione](#instances-on-premises-register-instance-3-install-command)
+ [Fase 4: Distribuire le revisioni dell'applicazione nell'istanza locale](#instances-on-premises-register-instance-4-deploy-revision)
+ [Fase 5: Tieni traccia delle distribuzioni sull'istanza locale](#instances-on-premises-register-instance-5-track-deployment)
## Passaggio 1: installa e configura l'istanza locale AWS CLI
1. Installa AWS CLI l'istanza locale. Segui le istruzioni riportate nella [Guida per l'utente AWS CLI nella](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html) *Guida per l'AWS Command Line Interface utente*.
**Nota**
CodeDeploy i comandi per lavorare con le istanze locali sono disponibili nella AWS CLI versione 1.7.19 e successive. Se lo hai AWS CLI già installato, chiama **aws --version** per verificarne la versione.
1. Configura AWS CLI l'istanza locale. Segui le istruzioni riportate nella Guida per [l'*AWS Command Line Interface utente* di AWS CLI Configurazione](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).
**Importante**
Durante la configurazione AWS CLI (ad esempio, chiamando il **aws configure** comando), assicurati di specificare l'ID della chiave segreta e la chiave di accesso segreta di un utente IAM che disponga almeno delle seguenti autorizzazioni di AWS accesso oltre alle autorizzazioni specificate in. [Prerequisiti per la configurazione di un'istanza locale](instances-on-premises-prerequisites.md) In questo modo è possibile scaricare e installare l' CodeDeploy agente sull'istanza locale. Le autorizzazioni di accesso potrebbero essere simili a queste:
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*",
"iam:CreateAccessKey",
"iam:CreateUser",
"iam:DeleteAccessKey",
"iam:DeleteUser",
"iam:DeleteUserPolicy",
"iam:ListAccessKeys",
"iam:ListUserPolicies",
"iam:PutUserPolicy",
"iam:GetUser",
"tag:getTagKeys",
"tag:getTagValues",
"tag:GetResources"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
}
]
}
```
Se visualizzi errori di accesso negato quando provi ad accedere a uno dei bucket Amazon S3 mostrati in precedenza, prova a omettere la `/*` parte della risorsa ARN del bucket, ad esempio. `arn:aws:s3:::aws-codedeploy-sa-east-1`
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*",
"iam:CreateAccessKey",
"iam:CreateUser",
"iam:DeleteAccessKey",
"iam:DeleteUser",
"iam:DeleteUserPolicy",
"iam:ListAccessKeys",
"iam:ListUserPolicies",
"iam:PutUserPolicy",
"iam:GetUser",
"tag:GetResources"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket2/*"
]
}
]
}
```
## Passaggio 2: chiama il comando register
Per questa fase, si presuppone che la registrazione dell'istanza locale venga eseguita dall'istanza locale stessa. È inoltre possibile registrare un'istanza locale da un dispositivo o un'istanza separato su cui è AWS CLI installata e configurata come descritto nel passaggio precedente.
Utilizzate AWS CLI per chiamare il comando [register](https://docs.aws.amazon.com/cli/latest/reference/deploy/register.html), specificando:
+ Un nome che identifica in modo univoco l'istanza locale CodeDeploy (con l'opzione). `--instance-name`
**Importante**
Per identificare più facilmente l'istanza locale in un secondo momento, soprattutto a scopo di debug, è consigliabile utilizzare un nome mappato ad alcune caratteristiche univoche dell'istanza locale (ad esempio, il numero di serie o un identificatore di asset interno, se applicabili). Se specificate un indirizzo MAC per un nome, tenete presente che gli indirizzi MAC contengono caratteri CodeDeploy non consentiti, come i due punti (). `:` Per un elenco dei caratteri consentiti, consulta [CodeDeploy quote](limits.md).
+ Facoltativamente, l'ARN di un utente IAM esistente che desideri associare a questa istanza locale (con `--iam-user-arn` l'opzione). **Per ottenere l'ARN di un utente IAM, chiama il comando [get-user](https://docs.aws.amazon.com/cli/latest/reference/iam/get-user.html) o scegli il nome utente IAM nella sezione **Utenti** della console IAM, quindi trova il valore User **ARN** nella sezione Summary.** Se questa opzione non è specificata, CodeDeploy creerà un utente IAM per tuo conto nel tuo AWS account e lo assocerà all'istanza locale.
**Importante**
Se specifichi l'opzione `--iam-user-arn`, devi anche creare manualmente il file di configurazione dell'istanza locale, come descritto in [Passaggio 4: aggiungere un file di configurazione all'istanza locale](register-on-premises-instance-iam-user-arn.md#register-on-premises-instance-iam-user-arn-4).
Puoi associare un solo utente IAM a una sola istanza locale. Il tentativo di associare un singolo utente IAM a più istanze locali può causare errori, distribuzioni non riuscite su tali istanze locali o distribuzioni su quelle istanze locali che sono bloccate in uno stato di sospeso perpetuo.
+ Facoltativamente, un set di tag di istanza locali (con l'`--tags`opzione) che CodeDeploy verranno utilizzati per identificare il set di istanze Amazon EC2 su cui eseguire la distribuzione. Specifica ciascun tag con `Key=tag-key,Value=tag-value` (ad esempio, `Key=Name,Value=Beta Key=Name,Value=WestRegion`). Se questa opzione non è specificata, non verrà registrato alcun tag. [Per registrare i tag in un secondo momento, chiama il comando -premises-instances. add-tags-to-on](https://docs.aws.amazon.com/cli/latest/reference/deploy/add-tags-to-on-premises-instances.html)
+ Facoltativamente, la AWS regione in cui verrà registrata l'istanza locale (con CodeDeploy l'opzione). `--region` Questa deve essere una delle regioni supportate elencate in [Regione e gli endpoint](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in *Riferimenti generali di AWS*(ad esempio,). `us-west-2` Se questa opzione non è specificata, verrà utilizzata la AWS regione predefinita associata all'utente IAM chiamante.
Esempio:
```
aws deploy register --instance-name AssetTag12010298EX --iam-user-arn arn:aws:iam::444455556666:user/CodeDeployUser-OnPrem --tags Key=Name,Value=CodeDeployDemo-OnPrem --region us-west-2
```
Il comando **register** funziona nel modo seguente:
1. Se non viene specificato alcun utente IAM esistente, crea un utente IAM, gli assegna le autorizzazioni richieste e genera la chiave segreta e la chiave di accesso segreta corrispondenti. L'istanza locale utilizzerà questo utente IAM e le relative autorizzazioni e credenziali per l'autenticazione e l'interazione. CodeDeploy
1. Registra l'istanza locale con. CodeDeploy
1. Se specificato, si associa CodeDeploy ai tag specificati con l'`--tags`opzione al nome dell'istanza registrata locale.
1. Se è stato creato un utente IAM, crea anche il file di configurazione richiesto nella stessa directory da cui è stato chiamato il **register** comando.
Se questo comando rileva errori, viene visualizzato un messaggio di errore che descrive in che modo è possibile completare manualmente i passaggi rimanenti. In caso contrario, viene visualizzato un messaggio che descrive come chiamare il comando **install**, come illustrato nella fase successiva.
## Passaggio 3: richiama il comando di installazione
Dall'istanza locale, usa AWS CLI per chiamare il comando [install](https://docs.aws.amazon.com/cli/latest/reference/deploy/install.html), specificando:
+ Il percorso del file di configurazione (con l'opzione `--config-file`).
+ Facoltativamente, se sostituire il file di configurazione già presente nell'istanza locale (con l'opzione `--override-config`). Se non specificato, il file di configurazione esistente non verrà sostituito.
+ Facoltativamente, la AWS regione in cui verrà registrata l'istanza locale CodeDeploy (con l'opzione). `--region` Questa deve essere una delle regioni supportate elencate in [Regione e gli endpoint](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in *Riferimenti generali di AWS*(ad esempio,). `us-west-2` Se questa opzione non è specificata, verrà utilizzata la AWS regione predefinita associata all'utente IAM chiamante.
+ Facoltativamente, una posizione personalizzata da cui installare l' CodeDeploy agente (con l'`--agent-installer`opzione). Questa opzione è utile per installare una versione personalizzata dell' CodeDeploy agente che CodeDeploy non è supportata ufficialmente (ad esempio una versione personalizzata basata sul repository dell'[CodeDeployagente](https://github.com/aws/aws-codedeploy-agent) in GitHub). Il valore deve essere il percorso verso un bucket Amazon S3 che contiene:
+ Uno script di installazione dell' CodeDeploy agente (per sistemi operativi basati su Linux o UNIX, simile al file di installazione nel repository degli [CodeDeployagenti](https://github.com/aws/aws-codedeploy-agent/blob/master/bin/install) in). GitHub
+ Un file del pacchetto di installazione CodeDeploy dell'agente (.msi) (per sistemi operativi basati su Windows).
Se questa opzione non è specificata, CodeDeploy farà del suo meglio per installare dalla propria posizione una versione dell' CodeDeploy agente ufficialmente supportata che sia compatibile con il sistema operativo sull'istanza locale.
Esempio:
```
aws deploy install --override-config --config-file /tmp/codedeploy.onpremises.yml --region us-west-2 --agent-installer s3://aws-codedeploy-us-west-2/latest/codedeploy-agent.msi
```
Il comando **install** funziona nel modo seguente:
1. Verifica se l'istanza locale è un'istanza Amazon EC2. In caso affermativo, viene visualizzato un messaggio di errore.
1. Copia il file di configurazione delle istanze locali dalla posizione specificata sull'istanza alla posizione in cui l' CodeDeploy agente prevede di trovarlo, a condizione che il file non si trovi già in quella posizione.
Per Ubuntu Server e Red Hat Enterprise Linux (RHEL), questo è/. `/etc/codedeploy-agent/conf` `codedeploy.onpremises.yml`
Per Windows Server, questo è`C:\ProgramData\Amazon\CodeDeploy`\$1`conf.onpremises.yml`.
Se l'opzione `--override-config` è stata specificata, crea o sovrascrive il file.
1. Installa l' CodeDeploy agente nell'istanza locale e quindi lo avvia.
## Fase 4: Distribuire le revisioni dell'applicazione nell'istanza locale
È ora possibile distribuire le revisioni dell'applicazione all'istanza locale registrata e contrassegnata.
Distribuisci le revisioni delle applicazioni sulle istanze locali in un modo simile alla distribuzione delle revisioni delle applicazioni sulle istanze Amazon EC2. Per istruzioni, consulta [Crea una distribuzione con CodeDeploy](deployments-create.md). Queste istruzioni rimandano ai prerequisiti, inclusa la creazione di un'applicazione, la creazione di un gruppo di distribuzione e la preparazione di una revisione di un'applicazione. Se occorre una semplice revisione dell'applicazione di esempio da distribuire, puoi creare quella descritta in [Passaggio 2: creare una revisione di esempio dell'applicazione](tutorials-on-premises-instance-2-create-sample-revision.md) nel [Tutorial: Implementa un'applicazione su un'istanza locale con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)](tutorials-on-premises-instance.md).
**Importante**
Se riutilizzi un ruolo di CodeDeploy servizio esistente come parte della creazione di un gruppo di distribuzione destinato alle istanze locali, devi includere `Tag:get*` nella parte della politica del ruolo di servizio. `Action` Per ulteriori informazioni, consulta [Fase 2: Creare un ruolo di servizio per CodeDeploy](getting-started-create-service-role.md).
## Fase 5: Tieni traccia delle distribuzioni sull'istanza locale
Dopo aver distribuito una revisione dell'applicazione a istanze locali registrate e contrassegnate, puoi monitorare l'avanzamento della distribuzione.
Tieni traccia delle distribuzioni su istanze locali in modo simile al monitoraggio delle distribuzioni su istanze Amazon EC2. Per istruzioni, consulta [Visualizza i dettagli CodeDeploy della distribuzione](deployments-view-details.md).
Per ulteriori opzioni, consulta [Gestione delle operazioni delle istanze locali in CodeDeploy](on-premises-instances-operations.md).
# Usa il register-on-premises-instance comando (utente IAM ARN) per registrare un'istanza locale
**Importante**
La registrazione di un'istanza utilizzando un utente IAM non è consigliata perché utilizza credenziali statiche (permanenti) per l'autenticazione. Per una maggiore sicurezza, consigliamo di registrare un'istanza utilizzando credenziali temporanee per l'autenticazione. Per ulteriori informazioni, consulta [Usa il register-on-premises-instance comando (IAM Session ARN) per registrare un'istanza locale](register-on-premises-instance-iam-session-arn.md).
**Importante**
Assicurati di disporre di un piano per la rotazione delle chiavi di accesso dell'utente IAM (credenziali permanenti). Per ulteriori informazioni, consulta [Rotazione](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_credentials_access-keys.html#Using_RotateAccessKey) delle chiavi di accesso.
Segui le istruzioni per configurare un'istanza locale, registrarla e applicarvi tag con CodeDeploy in modo prevalentemente autonomo utilizzando le credenziali utente IAM per l'autenticazione.
**Topics**
+ [Passaggio 1: creare un utente IAM per l'istanza locale](#register-on-premises-instance-iam-user-arn-1)
+ [Passaggio 2: assegna le autorizzazioni all'utente IAM](#register-on-premises-instance-iam-user-arn-2)
+ [Passaggio 3: Ottieni le credenziali utente IAM](#register-on-premises-instance-iam-user-arn-3)
+ [Passaggio 4: aggiungere un file di configurazione all'istanza locale](#register-on-premises-instance-iam-user-arn-4)
+ [Passaggio 5: installa e configura AWS CLI](#register-on-premises-instance-iam-user-arn-5)
+ [Passaggio 6: imposta la variabile di AWS\$1REGION ambiente (solo Ubuntu Server e RHEL)](#register-on-premises-instance-iam-user-arn-6)
+ [Fase 7: Installare l'agente CodeDeploy](#register-on-premises-instance-iam-user-arn-7)
+ [Passaggio 8: registrare l'istanza locale con CodeDeploy](#register-on-premises-instance-iam-user-arn-8)
+ [Passaggio 9: assegna un tag all'istanza locale](#register-on-premises-instance-iam-user-arn-9)
+ [Fase 10: Distribuire le revisioni delle applicazioni nell'istanza locale](#register-on-premises-instance-iam-user-arn-10)
+ [Fase 11: Tieni traccia delle distribuzioni sull'istanza locale](#register-on-premises-instance-iam-user-arn-11)
## Passaggio 1: creare un utente IAM per l'istanza locale
Crea un utente IAM che l'istanza locale utilizzerà per l'autenticazione e l'interazione. CodeDeploy
**Importante**
Devi creare un utente IAM separato per ogni istanza locale partecipante. Se provi a riutilizzare un singolo utente IAM per più istanze locali, potresti non riuscire a registrare o etichettare correttamente quelle istanze locali con. CodeDeploy Le distribuzioni in tali istanze locali potrebbero restare bloccate in uno stato di sospensione perpetuo o avere esito negativo.
Ti consigliamo di assegnare all'utente IAM un nome che ne identifichi lo scopo, ad esempio -. CodeDeployUser OnPrem
Puoi utilizzare la AWS CLI o la console IAM per creare un utente IAM. Per informazioni, consulta [Creazione di un utente IAM nel tuo AWS account](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html).
**Importante**
Sia che utilizzi la console IAM AWS CLI o la console IAM per creare un nuovo utente IAM, prendi nota dell'ARN utente fornito all'utente. Queste informazioni ti serviranno in seguito in [Passaggio 4: aggiungere un file di configurazione all'istanza locale](#register-on-premises-instance-iam-user-arn-4) e [Passaggio 8: registrare l'istanza locale con CodeDeploy](#register-on-premises-instance-iam-user-arn-8).
## Passaggio 2: assegna le autorizzazioni all'utente IAM
Se la tua istanza locale distribuirà revisioni di applicazioni da bucket Amazon S3, devi assegnare all'utente IAM le autorizzazioni per interagire con tali bucket. Puoi utilizzare la console o la console IAM per assegnare le AWS CLI autorizzazioni.
**Nota**
Se intendi distribuire le revisioni delle applicazioni solo dai GitHub repository, salta questo passaggio e vai direttamente a. [Passaggio 3: Ottieni le credenziali utente IAM](#register-on-premises-instance-iam-user-arn-3) (Avrai comunque bisogno di informazioni sull'utente IAM in cui hai creato. [Passaggio 1: creare un utente IAM per l'istanza locale](#register-on-premises-instance-iam-user-arn-1) Verrà utilizzato nei passaggi successivi.)
**Per assegnare le autorizzazioni (CLI)**
1. Crea un file con i seguenti contenuti della policy sull'istanza o sul dispositivo Amazon EC2 che stai utilizzando per chiamare il. AWS CLI Assegnare al file un nome tipo **CodeDeploy-OnPrem-Permissions.json** e salvarlo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
**Nota**
Ti consigliamo di limitare questa politica solo ai bucket Amazon S3 a cui deve accedere l'istanza locale. Se limiti questa politica, assicurati di consentire l'accesso anche ai bucket Amazon S3 che contengono l'agente. AWS CodeDeploy In caso contrario, potrebbe verificarsi un errore ogni volta che l' CodeDeploy agente viene installato o aggiornato sull'istanza locale associata.
Esempio:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:Get*",
"s3:List*"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::aws-codedeploy-us-east-2/*",
"arn:aws:s3:::aws-codedeploy-us-east-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-2/*",
"arn:aws:s3:::aws-codedeploy-ca-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-2/*",
"arn:aws:s3:::aws-codedeploy-eu-west-3/*",
"arn:aws:s3:::aws-codedeploy-eu-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-central-2/*",
"arn:aws:s3:::aws-codedeploy-eu-north-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-2/*",
"arn:aws:s3:::aws-codedeploy-il-central-1/*",
"arn:aws:s3:::aws-codedeploy-ap-east-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-4/*",
"arn:aws:s3:::aws-codedeploy-ap-south-1/*",
"arn:aws:s3:::aws-codedeploy-ap-south-2/*",
"arn:aws:s3:::aws-codedeploy-me-central-1/*",
"arn:aws:s3:::aws-codedeploy-me-south-1/*",
"arn:aws:s3:::aws-codedeploy-sa-east-1/*"
]
}
]
}
```
1. Chiama il [put-user-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-user-policy.html)comando, specificando il nome dell'utente IAM (con l'`--user-name`opzione), un nome per la policy (con l'`--policy-name`opzione) e il percorso del documento di policy appena creato (con l'`--policy-document`opzione). Ad esempio, presupponendo che il file **CodeDeploy-OnPrem-Permissions.json** si trovi nella stessa directory (cartella) da cui si sta chiamando il comando:
**Importante**
Assicurarsi di includere `file://` prima del nome del file. Questo è obbligatorio in questo comando.
```
aws iam put-user-policy --user-name CodeDeployUser-OnPrem --policy-name CodeDeploy-OnPrem-Permissions --policy-document file://CodeDeploy-OnPrem-Permissions.json
```
**Per assegnare le autorizzazioni (console)**
1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nel riquadro di navigazione, seleziona **Policies (Policy)** e **Create Policy (Crea policy)**. (Se viene visualizzato il pulsante **Get Started (Inizia)**, sceglierlo, quindi scegliere **Create Policy (Crea policy)**).
1. Accanto a **Create Your Own Policy** (Crea la tua policy) scegli **Select** (Seleziona).
1. Nella casella **Policy Name (Nome policy)** digitare un nome per questa policy (ad esempio **CodeDeploy-OnPrem-Permissions**).
1. Nella casella **Policy Document**, digita o incolla la seguente espressione di autorizzazione, che consente di AWS CodeDeploy distribuire le revisioni delle applicazioni da qualsiasi bucket Amazon S3 specificato nella policy all'istanza locale per conto dell'utente IAM:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
1. Scegli **Crea policy**.
1. Nel pannello di navigazione, scegliere **Users (Utenti)**.
1. Nell'elenco degli utenti, cerca e scegli il nome dell'utente IAM in cui hai creato. [Passaggio 1: creare un utente IAM per l'istanza locale](#register-on-premises-instance-iam-user-arn-1)
1. Nella scheda **Permissions (Autorizzazioni)**, in **Managed Policies (Policy gestite)**, selezionare **Attach Policy (Collega policy)**.
1. Selezionare la policy denominata **CodeDeploy-OnPrem-Permissions**, quindi scegliere **Attach Policy (Collega policy)**.
## Passaggio 3: Ottieni le credenziali utente IAM
Ottieni l'ID della chiave segreta e la chiave di accesso segreta per l'utente IAM. che serviranno per [Passaggio 4: aggiungere un file di configurazione all'istanza locale](#register-on-premises-instance-iam-user-arn-4). Puoi utilizzare la console AWS CLI o la console IAM per ottenere l'ID della chiave segreta e la chiave di accesso segreta.
**Nota**
Se già si dispone dell'ID chiave segreta e dell'ID chiave di accesso segreta, saltare questo passaggio e passare direttamente a [Passaggio 4: aggiungere un file di configurazione all'istanza locale](#register-on-premises-instance-iam-user-arn-4).
Gli utenti necessitano di un accesso programmatico se desiderano interagire con l' AWS Console di gestione AWS esterno di. Il modo per concedere l'accesso programmatico dipende dal tipo di utente che accede. AWS
Per fornire agli utenti l’accesso programmatico, scegli una delle seguenti opzioni.
****
| Quale utente necessita dell’accesso programmatico? | Per | Come |
| --- | --- | --- |
| IAM | (Consigliato) Utilizza le credenziali della console come credenziali temporanee per firmare le richieste programmatiche a,, o. AWS CLI AWS SDKs AWS APIs | Segui le istruzioni per l’interfaccia che desideri utilizzare. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/register-on-premises-instance-iam-user-arn.html) |
| Identità della forza lavoro (Utenti gestiti nel centro identità IAM) | Utilizza credenziali temporanee per firmare le richieste programmatiche a AWS CLI, AWS SDKs, o. AWS APIs | Segui le istruzioni per l’interfaccia che desideri utilizzare. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/register-on-premises-instance-iam-user-arn.html) |
| IAM | Utilizza credenziali temporanee per firmare le richieste programmatiche a AWS CLI, AWS SDKs, o. AWS APIs | Seguendo le istruzioni riportate in [Utilizzo delle credenziali temporanee con le AWS risorse nella Guida per](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) l'utente IAM. |
| IAM | (Non consigliato)Utilizza credenziali a lungo termine per firmare richieste programmatiche a AWS CLI,, AWS SDKs o. AWS APIs | Segui le istruzioni per l’interfaccia che desideri utilizzare. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/register-on-premises-instance-iam-user-arn.html) |
**Per ottenere le credenziali (CLI)**
1. Chiama il [list-access-keys](https://docs.aws.amazon.com/cli/latest/reference/iam/list-access-keys.html)comando, specificando il nome dell'utente IAM (con l'`--user-name`opzione) e interrogando solo la chiave di accesso IDs (con le `--query` opzioni and). `--output` Esempio:
```
aws iam list-access-keys --user-name CodeDeployUser-OnPrem --query "AccessKeyMetadata[*].AccessKeyId" --output text
```
1. Se nell'output non appare alcuna chiave o nell'output compaiono informazioni su una sola chiave, chiama il [create-access-key](https://docs.aws.amazon.com/cli/latest/reference/iam/create-access-key.html)comando, specificando il nome dell'utente IAM (con l'`--user-name`opzione):
```
aws iam create-access-key --user-name CodeDeployUser-OnPrem
```
Nell'output della chiamata al comando **create-access-key** prendere nota del valore dei campi `AccessKeyId` e `SecretAccessKey`. Queste informazioni serviranno in [Passaggio 4: aggiungere un file di configurazione all'istanza locale](#register-on-premises-instance-iam-user-arn-4).
**Importante**
Sarà l'unica volta che si avrà accesso a questa chiave di accesso segreta. Se si dimentica o si perde l'accesso a questa chiave di accesso segreta, sarà necessario generarne una nuova seguendo le fasi descritte in [Passaggio 3: Ottieni le credenziali utente IAM](#register-on-premises-instance-iam-user-arn-3).
1. Se sono già elencate due chiavi di accesso, devi eliminarne una chiamando il [delete-access-key](https://docs.aws.amazon.com/cli/latest/reference/iam/delete-access-key.html)comando, specificando il nome dell'utente IAM (con l'`--user-name`opzione) e l'ID della chiave di accesso da eliminare (con l'`--access-key-id`opzione). Quindi chiamare il comando **create-access-key**, come descritto precedentemente in questa fase. Ecco un esempio di utilizzo del comando **delete-access-key**:
```
aws iam delete-access-key --user-name CodeDeployUser-OnPrem --access-key-id access-key-ID
```
**Importante**
Se chiami il **delete-access-key** comando per eliminare una di queste chiavi di accesso e un'istanza locale sta già utilizzando questa chiave di accesso come descritto in[Passaggio 4: aggiungere un file di configurazione all'istanza locale](#register-on-premises-instance-iam-user-arn-4), dovrai seguire [Passaggio 4: aggiungere un file di configurazione all'istanza locale](#register-on-premises-instance-iam-user-arn-4) nuovamente le istruzioni per specificare un ID chiave di accesso e una chiave di accesso segreta diversi associati a questo utente IAM. In caso contrario, le distribuzioni in questa istanza locale potrebbero restare bloccate in uno stato di sospensione perpetuo o avere esito negativo.
**Per ottenere le credenziali (console)**
1.
1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Se l'elenco di utenti non è visualizzato, nel riquadro di navigazione scegliere **Users (Utenti)**.
1. Nell'elenco degli utenti, cerca e scegli il nome dell'utente IAM in [Passaggio 1: creare un utente IAM per l'istanza locale](#register-on-premises-instance-iam-user-arn-1) cui hai creato.
1. Nella scheda **Security credentials (Credenziali di sicurezza)**, se nell'elenco non sono presenti chiavi, o è presente una sola chiave, scegliere **Create access key (Crea chiave di accesso)**.
Se nell'elenco sono presenti due chiavi di accesso, è necessario eliminarne una. Selezionare **Delete (Elimina)** accanto a una delle chiavi di accesso, quindi scegliere **Create access key (Crea chiave di accesso)**.
**Importante**
Se scegli **Elimina** accanto a una di queste chiavi di accesso e un'istanza locale utilizza già questa chiave di accesso come descritto in[Passaggio 4: aggiungere un file di configurazione all'istanza locale](#register-on-premises-instance-iam-user-arn-4), dovrai seguire [Passaggio 4: aggiungere un file di configurazione all'istanza locale](#register-on-premises-instance-iam-user-arn-4) nuovamente le istruzioni per specificare un ID della chiave di accesso e una chiave di accesso segreta diversi associati a questo utente IAM. In caso contrario, le distribuzioni in questa istanza locale potrebbero restare bloccate in uno stato di sospensione perpetuo o avere esito negativo.
1. Selezionare **Show (Mostra)** e prendere nota dell'ID chiave di accesso e della chiave di accesso segreta. Queste informazioni serviranno per la fase successiva. In alternativa, selezionare **Download .csv file (Scarica file .csv)** per salvare una copia dell'ID chiave di accesso e la chiave di accesso segreta.
**Importante**
Se non si prende nota o si scaricano le credenziali, questa sarà l'unica volta che si avrà accesso a questa chiave di accesso segreta. Se si dimentica o si perde l'accesso a questa chiave di accesso segreta, sarà necessario generarne una nuova seguendo le fasi descritte in [Passaggio 3: Ottieni le credenziali utente IAM](#register-on-premises-instance-iam-user-arn-3).
1. Scegli **Chiudi** per tornare alla *IAM User Name* pagina **Utenti >**.
## Passaggio 4: aggiungere un file di configurazione all'istanza locale
Aggiungi un file di configurazione all'istanza locale, utilizzando le autorizzazioni dell'utente root o amministratore. Questo file di configurazione verrà utilizzato per dichiarare le credenziali utente IAM e la AWS regione di destinazione per cui utilizzare. CodeDeploy Il file deve essere aggiunto in una posizione specifica dell'istanza locale. Il file deve includere l'ARN dell'utente IAM, l'ID della chiave segreta, la chiave di accesso segreta e la regione di destinazione AWS . Il file deve seguire un formato specifico.
1. Crea un file denominato `codedeploy.onpremises.yml` (per un'istanza locale di Ubuntu Server o RHEL) o `conf.onpremises.yml` (per un'istanza locale di Windows Server) nella seguente posizione sull'istanza locale:
+ Per Ubuntu Server: `/etc/codedeploy-agent/conf`
+ Per Windows Server: `C:\ProgramData\Amazon\CodeDeploy`
1. Utilizzare un editor di testo per aggiungere le seguenti informazioni al nuovo file `codedeploy.onpremises.yml` o `conf.onpremises.yml` creato:
```
---
aws_access_key_id: secret-key-id
aws_secret_access_key: secret-access-key
iam_user_arn: iam-user-arn
region: supported-region
```
Dove:
+ *secret-key-id*è l'ID della chiave segreta dell'utente IAM corrispondente che hai annotato [Passaggio 1: creare un utente IAM per l'istanza locale](#register-on-premises-instance-iam-user-arn-1) o[Passaggio 3: Ottieni le credenziali utente IAM](#register-on-premises-instance-iam-user-arn-3).
+ *secret-access-key*è la chiave di accesso segreta dell'utente IAM corrispondente che hai annotato in [Passaggio 1: creare un utente IAM per l'istanza locale](#register-on-premises-instance-iam-user-arn-1) o[Passaggio 3: Ottieni le credenziali utente IAM](#register-on-premises-instance-iam-user-arn-3).
+ *iam-user-arn*è l'ARN dell'utente IAM che hai annotato in precedenza. [Passaggio 1: creare un utente IAM per l'istanza locale](#register-on-premises-instance-iam-user-arn-1)
+ *supported-region*è l'identificatore di una regione supportata da CodeDeploy dove si trovano le CodeDeploy applicazioni, i gruppi di distribuzione e le revisioni delle applicazioni (ad esempio,). `us-west-2` Per un elenco delle regioni, consulta [Regione ed endpoint](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in. *Riferimenti generali di AWS*
**Importante**
Se hai scelto **Elimina** accanto a una delle chiavi di accesso in [Passaggio 3: Ottieni le credenziali utente IAM](#register-on-premises-instance-iam-user-arn-3) e l'istanza locale utilizza già l'ID della chiave di accesso e la chiave di accesso segreta associati, dovrai seguire le istruzioni riportate per specificare un ID chiave di [Passaggio 4: aggiungere un file di configurazione all'istanza locale](#register-on-premises-instance-iam-user-arn-4) accesso e una chiave di accesso segreta diversi associati a questo utente IAM. In caso contrario, le distribuzioni nella propria istanza locale potrebbero restare bloccate in uno stato di sospensione perpetuo o avere esito negativo.
## Passaggio 5: installa e configura AWS CLI
Installa e configura AWS CLI l'istanza locale. ( AWS CLI Verrà utilizzato [Fase 7: Installare l'agente CodeDeploy](#register-on-premises-instance-iam-user-arn-7) per scaricare e installare l' CodeDeploy agente sull'istanza locale.)
1. Per installare l' AWS CLI istanza locale, segui le istruzioni riportate nella [Guida](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html) per l'utente AWS CLI nella Guida per l'*AWS Command Line Interface utente*.
**Nota**
CodeDeploy i comandi per lavorare con le istanze locali sono diventati disponibili nella versione 1.7.19 di. AWS CLI Se hai una versione di quella AWS CLI già installata, puoi verificarne la versione chiamando. **aws --version**
1. Per configurare l' AWS CLI istanza locale, segui le istruzioni in [Configurazione della istanza locale nella Guida AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) per l'*AWS Command Line Interface utente*.
**Importante**
Durante la configurazione AWS CLI (ad esempio, chiamando il **aws configure** comando), assicurati di specificare l'ID della chiave segreta e la chiave di accesso segreta di un utente IAM che disponga almeno delle seguenti autorizzazioni di AWS accesso oltre alle autorizzazioni di accesso specificate in. [Prerequisiti per la configurazione di un'istanza locale](instances-on-premises-prerequisites.md) In questo modo è possibile scaricare e installare l' CodeDeploy agente sull'istanza locale:
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
}
]
}
```
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"*"
]
}
]
}
```
Queste autorizzazioni di accesso possono essere assegnate all'utente IAM in cui hai creato [Passaggio 1: creare un utente IAM per l'istanza locale](#register-on-premises-instance-iam-user-arn-1) o a un altro utente IAM. Per assegnare queste autorizzazioni a un utente IAM, segui le istruzioni riportate in[Passaggio 1: creare un utente IAM per l'istanza locale](#register-on-premises-instance-iam-user-arn-1), utilizzando queste autorizzazioni di accesso anziché quelle descritte in quella fase.
## Passaggio 6: imposta la variabile di AWS\$1REGION ambiente (solo Ubuntu Server e RHEL)
Se non esegui Ubuntu Server o RHEL sulla tua istanza locale, salta questo passaggio e vai direttamente a. [Fase 7: Installare l'agente CodeDeploy](#register-on-premises-instance-iam-user-arn-7)
Installa l' CodeDeploy agente su un'istanza locale di Ubuntu Server o RHEL e abilita l'istanza ad aggiornare l' CodeDeploy agente ogni volta che diventa disponibile una nuova versione. A questo scopo, imposta la variabile di ambiente `AWS_REGION` nell'istanza sull'identificatore di una delle regioni supportate da CodeDeploy. Si consiglia di impostare il valore sulla regione in cui si trovano CodeDeploy le applicazioni, i gruppi di distribuzione e le revisioni delle applicazioni (ad esempio,). `us-west-2` Per un elenco delle regioni, consulta [Regione ed endpoint](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in. *Riferimenti generali di AWS*
Per impostare la variabile di ambiente, esegui la chiamata seguente dal terminale:
```
export AWS_REGION=supported-region
```
*supported-region*Dov'è l'identificatore della regione (ad esempio,`us-west-2`).
## Fase 7: Installare l'agente CodeDeploy
Installa l' CodeDeploy agente sull'istanza locale:
+ Per un'istanza locale di Ubuntu Server, segui le istruzioni riportate in[Installa l' CodeDeploy agente per Ubuntu Server](codedeploy-agent-operations-install-ubuntu.md), quindi torna a questa pagina.
+ Per un'istanza RHEL locale, segui le istruzioni riportate in[Installa l' CodeDeploy agente per Amazon Linux o RHEL](codedeploy-agent-operations-install-linux.md), quindi torna a questa pagina.
+ Per un'istanza locale di Windows Server, segui le istruzioni riportate e torna a questa pagina. [Installa l' CodeDeploy agente per Windows Server](codedeploy-agent-operations-install-windows.md)
## Passaggio 8: registrare l'istanza locale con CodeDeploy
Le istruzioni in questa fase presumono che la registrazione dell'istanza locale venga eseguita dall'istanza locale stessa. È possibile registrare un'istanza locale da un dispositivo o un'istanza separato su cui è AWS CLI installata e configurata, come descritto in. [Passaggio 5: installa e configura AWS CLI](#register-on-premises-instance-iam-user-arn-5)
Utilizza il AWS CLI per registrare l'istanza locale CodeDeploy in modo che possa essere utilizzata nelle distribuzioni.
1. Prima di poter utilizzare il AWS CLI, è necessario l'ARN dell'utente IAM in cui è stato creato. [Passaggio 1: creare un utente IAM per l'istanza locale](#register-on-premises-instance-iam-user-arn-1) Se non disponi già dell'ARN dell'utente, chiama il comando [get-user](https://docs.aws.amazon.com/cli/latest/reference/iam/get-user.html), specificando il nome dell'utente IAM (con l'`--user-name`opzione) ed eseguendo una query solo per l'utente ARN (con le opzioni and): `--query` `--output`
```
aws iam get-user --user-name CodeDeployUser-OnPrem --query "User.Arn" --output text
```
1. Chiama il comando [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html), specificando:
+ Un nome che identifica in modo univoco l'istanza locale (con l'opzione `--instance-name`).
**Importante**
Per identificare più facilmente l'istanza locale, soprattutto a scopo di debug, consigliamo di specificare un nome mappato ad alcune caratteristiche univoche dell'istanza locale (ad esempio, il numero di serie o un identificatore di asset interno, se applicabili). Se specificate un indirizzo MAC come nome, tenete presente che gli indirizzi MAC contengono caratteri CodeDeploy non consentiti, come colon (). `:` Per un elenco dei caratteri consentiti, consulta [CodeDeploy quote](limits.md).
+ L'ARN utente dell'utente IAM in cui hai creato [Passaggio 1: creare un utente IAM per l'istanza locale](#register-on-premises-instance-iam-user-arn-1) (con l'`--iam-user-arn`opzione).
Esempio:
```
aws deploy register-on-premises-instance --instance-name AssetTag12010298EX --iam-user-arn arn:aws:iam::444455556666:user/CodeDeployUser-OnPrem
```
## Passaggio 9: assegna un tag all'istanza locale
Puoi utilizzare la AWS CLI o la CodeDeploy console per etichettare l'istanza locale. (CodeDeployutilizza i tag delle istanze locali per identificare gli obiettivi di distribuzione durante una distribuzione.)
**Per applicare tag all'istanza locale (CLI)**
+ Chiama il comando [add-tags-to-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/add-tags-to-on-premises-instances.html), specificando:
+ Il nome che identifica in modo univoco l'istanza locale (con l'opzione `--instance-names`).
+ Il nome della chiave tag e del valore tag dell'istanza locale che si desidera utilizzare (con l'opzione `--tags`). È necessario specificare sia un nome che un valore. CodeDeploy non consente tag di istanza locali con solo valori.
Esempio:
```
aws deploy add-tags-to-on-premises-instances --instance-names AssetTag12010298EX --tags Key=Name,Value=CodeDeployDemo-OnPrem
```
**Per applicare tag all'istanza locale (console)**
1. Accedi a Console di gestione AWS e apri la CodeDeploy console all'indirizzo [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
**Nota**
Accedi con lo stesso utente con cui hai effettuato la configurazione. [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md)
1. Dal CodeDeploy menu, scegli **Istanze locali**.
1. Nell'elenco delle istanze locali scegliere la freccia accanto all'istanza locale a cui si desidera applicare tag.
1. Nell'elenco di tag, selezionare o immettere la chiave tag e il valore tag desiderati. Dopo aver immesso la chiave tag e il valore tag, viene visualizzata un'altra riga. È possibile ripetere questa operazione fino a 10 tag. Per rimuovere un tag, scegliere l'icona di eliminazione (![\[The delete icon.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/delete-triggers-x.png)).
1. Dopo aver aggiunto i tag, scegliere **Update Tags (Aggiorna tag)**.
## Fase 10: Distribuire le revisioni delle applicazioni nell'istanza locale
È ora possibile distribuire le revisioni dell'applicazione all'istanza locale registrata e contrassegnata.
Distribuisci le revisioni delle applicazioni sulle istanze locali in un modo simile alla distribuzione delle revisioni delle applicazioni sulle istanze Amazon EC2. Per istruzioni, consulta [Crea una distribuzione con CodeDeploy](deployments-create.md). Queste istruzioni includono un link ai prerequisiti, inclusa la creazione di un'applicazione, la creazione di un gruppo di distribuzione e la preparazione di una revisione dell'applicazione. Se occorre una semplice revisione dell'applicazione di esempio da distribuire, puoi creare quella descritta in [Passaggio 2: creare una revisione di esempio dell'applicazione](tutorials-on-premises-instance-2-create-sample-revision.md) nel [Tutorial: Implementa un'applicazione su un'istanza locale con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)](tutorials-on-premises-instance.md).
**Importante**
Se riutilizzi un ruolo di CodeDeploy servizio come parte della creazione di un gruppo di distribuzione destinato alle istanze locali, devi includere `Tag:get*` nella parte della politica del ruolo di servizio. `Action` Per ulteriori informazioni, consulta [Fase 2: Creare un ruolo di servizio per CodeDeploy](getting-started-create-service-role.md).
## Fase 11: Tieni traccia delle distribuzioni sull'istanza locale
Dopo aver distribuito una revisione dell'applicazione a istanze locali registrate e contrassegnate, puoi monitorare l'avanzamento della distribuzione.
Tieni traccia delle distribuzioni su istanze locali in modo simile al monitoraggio delle distribuzioni su istanze Amazon EC2. Per istruzioni, consulta [Visualizza i dettagli CodeDeploy della distribuzione](deployments-view-details.md).
# Gestione delle operazioni delle istanze locali in CodeDeploy
Segui le istruzioni in questa sezione per gestire le operazioni sulle istanze locali dopo averle registrate CodeDeploy, ad esempio per ottenere maggiori informazioni, rimuovere i tag e disinstallare e annullare la registrazione delle istanze locali.
**Topics**
+ [Ottieni informazioni su una singola istanza locale](on-premises-instances-operations-view-details-single.md)
+ [Ottieni informazioni su più istanze locali](on-premises-instances-operations-view-details-multiple.md)
+ [Rimuovi manualmente i tag delle istanze locali da un'istanza locale](on-premises-instances-operations-remove-tags.md)
+ [Disinstalla automaticamente l' CodeDeploy agente e rimuovi il file di configurazione da un'istanza locale](on-premises-instances-operations-uninstall-agent.md)
+ [Annulla automaticamente la registrazione di un'istanza locale](on-premises-instances-operations-deregister-automatically.md)
+ [Annulla manualmente la registrazione di un'istanza locale](on-premises-instances-operations-deregister-manually.md)
# Ottieni informazioni su una singola istanza locale
È possibile ottenere informazioni su una singola istanza locale seguendo le istruzioni in [Visualizza i dettagli CodeDeploy della distribuzione](deployments-view-details.md). Puoi utilizzare la console AWS CLI o la CodeDeploy console per ottenere ulteriori informazioni su una singola istanza locale.
**Per ottenere informazioni su una singola istanza locale (CLI)**
+ Chiamare il comando [get-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-on-premises-instance.html), specificando il nome che identifica in modo univoco l'istanza locale (con l'opzione `--instance-name`):
```
aws deploy get-on-premises-instance --instance-name AssetTag12010298EX
```
**Per ottenere informazioni su una singola istanza locale (console)**
1. Accedi Console di gestione AWS e apri la CodeDeploy console all'indirizzo [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
**Nota**
Accedi con lo stesso utente con cui hai effettuato la configurazione. [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md)
1. Nel riquadro di navigazione, espandi **Deploy** e scegli Istanze **locali**.
1. Nell'elenco delle istanze locali, scegliere il nome di un'istanza locale per visualizzarne i dettagli.
# Ottieni informazioni su più istanze locali
È possibile ottenere informazioni sulle istanze locali seguendo le istruzioni in [Visualizza i dettagli CodeDeploy della distribuzione](deployments-view-details.md). Puoi utilizzare la console AWS CLI o la CodeDeploy console per ottenere maggiori informazioni sulle istanze locali.
**Per ottenere informazioni su più istanze locali (CLI)**
1. Per un elenco dei nomi di istanza locale, chiamare il comando [list-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-on-premises-instances.html), specificando:
+ Se si desidera ottenere informazioni su tutte le istanze locali registrate o con registrazione annullata (rispettivamente con l'opzione `--registration-status` e `Registered` o `Deregistered`). Se si omette questa informazione, vengono restituiti i nomi delle istanze locali sia registrate sia con registrazione annullata.
+ Se si desidera ottenere informazioni solo sulle istanze locali a cu sono applicati tag di istanze locali specifici (con l'opzione `--tag-filters`). Per ogni tag di istanza locale, specificare `Key`, `Value` e `Type` (che deve essere sempre `KEY_AND_VALUE`). Separare più tag di istanze locali inserendo uno spazio tra una terna formata da `Key`, `Value` e `Type` e quella successiva.
Esempio:
```
aws deploy list-on-premises-instances --registration-status Registered --tag-filters Key=Name,Value=CodeDeployDemo-OnPrem,Type=KEY_AND_VALUE Key=Name,Value=CodeDeployDemo-OnPrem-Beta,Type=KEY_AND_VALUE
```
1. Per informazioni più dettagliate, chiama il comando [batch-get-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/batch-get-on-premises-instances.html), con i nomi delle istanze locali (con l'opzione): `--instance-names`
```
aws deploy batch-get-on-premises-instances --instance-names AssetTag12010298EX AssetTag09920444EX
```
**Per ottenere informazioni su più istanze locali (console)**
1. [Accedi Console di gestione AWS e apri la console all'indirizzo /codedeploy. CodeDeploy https://console.aws.amazon.com](https://console.aws.amazon.com/codedeploy)
**Nota**
Accedi con lo stesso utente con cui hai effettuato la configurazione. [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md)
1. Nel riquadro di navigazione, espandi **Deploy** e scegli Istanze **locali**.
Vengono visualizzate le informazioni sulle istanze locali.
# Rimuovi manualmente i tag delle istanze locali da un'istanza locale
Generalmente si rimuove un tag che non viene più utilizzato da un'istanza locale oppure si rimuove l'istanza locale dai gruppi di distribuzione che si basano su quel tag. Puoi utilizzare la console AWS CLI o la AWS CodeDeploy console per rimuovere i tag delle istanze locali dalle istanze locali.
Non è necessario eliminare i tag da un'istanza locale prima di annullare la registrazione.
La rimozione manuale dei tag da un'istanza locale non ne annulla la registrazione. Non disinstalla l' CodeDeploy agente dall'istanza. Non rimuove il file di configurazione dall'istanza. Non elimina l'utente IAM associato all'istanza.
Per annullare automaticamente la registrazione dell'istanza locale, consulta [Annulla automaticamente la registrazione di un'istanza locale](on-premises-instances-operations-deregister-automatically.md).
Per annullare manualmente la registrazione dell'istanza locale, consulta [Annulla manualmente la registrazione di un'istanza locale](on-premises-instances-operations-deregister-manually.md).
Per disinstallare automaticamente l' CodeDeploy agente e rimuovere il file di configurazione dall'istanza locale, consulta[Disinstalla automaticamente l' CodeDeploy agente e rimuovi il file di configurazione da un'istanza locale](on-premises-instances-operations-uninstall-agent.md).
Per disinstallare manualmente solo l' CodeDeploy agente dall'istanza locale, consulta. [Gestione delle operazioni degli CodeDeploy agenti](codedeploy-agent-operations.md)
Per eliminare manualmente l'utente IAM associato, consulta [Eliminazione di un utente IAM dal tuo AWS account](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_DeletingUserFromAccount.html).
**Per rimuovere i tag da un'istanza locale (CLI)**
+ Chiama [remove-tags-from-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/remove-tags-from-on-premises-instances.html), specificando:
+ I nomi che identificano in modo univoco l'istanza locale (con l'opzione `--instance-names`).
+ I nomi e i valori dei tag che si desidera rimuovere (con l'opzione `--tags`).
Esempio:
```
aws deploy remove-tags-from-on-premises-instances --instance-names AssetTag12010298EX --tags Key=Name,Value=CodeDeployDemo-OnPrem
```
**Per rimuovere i tag da un'istanza locale (console)**
1. [Accedi a Console di gestione AWS e apri la console all'indirizzo /codedeploy. CodeDeploy https://console.aws.amazon.com](https://console.aws.amazon.com/codedeploy)
**Nota**
Accedi con lo stesso utente con cui hai effettuato la configurazione. [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md)
1. Nel riquadro di navigazione, espandi **Deploy** e scegli Istanze **locali**.
1. Nell'elenco delle istanze locali, scegliere il nome dell'istanza locale da cui si desidera rimuovere i tag.
1. Nella sezione **Tags (Tag)** scegliere **Remove (Rimuovi)** accanto a ogni tag che si desidera rimuovere.
1. Dopo avere eliminato i tag, scegliere **Update tags (Aggiorna tag)**.
# Disinstalla automaticamente l' CodeDeploy agente e rimuovi il file di configurazione da un'istanza locale
In genere, si disinstalla l' CodeDeploy agente e si rimuove il file di configurazione da un'istanza locale dopo che non si prevede più di distribuirla.
**Nota**
La disinstallazione automatica dell' CodeDeploy agente e la rimozione del file di configurazione da un'istanza locale non annullano la registrazione di un'istanza locale. Non elimina l'associazione dei tag associati all'istanza locale. Non elimina l'utente IAM associato all'istanza locale.
Per annullare automaticamente la registrazione dell'istanza locale, consulta [Annulla automaticamente la registrazione di un'istanza locale](on-premises-instances-operations-deregister-automatically.md).
Per annullare manualmente la registrazione dell'istanza locale, consulta [Annulla manualmente la registrazione di un'istanza locale](on-premises-instances-operations-deregister-manually.md).
Per annullare manualmente l'associazione di tag di istanze locali associati, consulta [Rimuovi manualmente i tag delle istanze locali da un'istanza locale](on-premises-instances-operations-remove-tags.md).
Per disinstallare manualmente l' CodeDeploy agente dall'istanza locale, consulta. [Gestione delle operazioni degli CodeDeploy agenti](codedeploy-agent-operations.md)
Per eliminare manualmente l'utente IAM associato, consulta [Eliminazione di un utente IAM dal tuo AWS account](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_DeletingUserFromAccount.html).
Dall'istanza locale, usa il comando AWS CLI to call il comando [uninstall](https://docs.aws.amazon.com/cli/latest/reference/deploy/uninstall.html).
Esempio:
```
aws deploy uninstall
```
Il comando **uninstall** funziona nel modo seguente:
1. Arresta l' CodeDeploy agente in esecuzione sull'istanza locale.
1. Disinstalla l' CodeDeploy agente dall'istanza locale.
1. Rimuove il file di configurazione dall'istanza locale. (Per Ubuntu Server e RHEL, questo è/. `/etc/codedeploy-agent/conf` `codedeploy.onpremises.yml` Per Windows Server, questo è`C:\ProgramData\Amazon\CodeDeploy`\$1`conf.onpremises.yml`.)
# Annulla automaticamente la registrazione di un'istanza locale
Generalmente si annulla la registrazione di un'istanza locale quando non si ha più intenzione di distribuire in quell'istanza. Quando si annulla la registrazione di un'istanza locale, anche se l'istanza locale potrebbe essere parte dei tag delle istanze locali di un gruppo di distribuzione, l'istanza locale non viene inclusa in alcuna distribuzione. Puoi utilizzarlo per annullare la registrazione delle AWS CLI istanze locali.
**Nota**
Non è possibile utilizzare la CodeDeploy console per annullare la registrazione di un'istanza locale. Inoltre, l'annullamento della registrazione di un'istanza locale rimuove l'associazione dei tag a tale istanza locale. Non disinstalla l' CodeDeploy agente dall'istanza locale. Non rimuove il file di configurazione dell'istanza locale dall'istanza.
Per utilizzare la CodeDeploy console per eseguire alcune (ma non tutte) le attività di questa sezione, consulta la sezione dedicata alla CodeDeploy console di[Annulla manualmente la registrazione di un'istanza locale](on-premises-instances-operations-deregister-manually.md).
Per annullare manualmente l'associazione di tag di istanze locali associati, consulta [Rimuovi manualmente i tag delle istanze locali da un'istanza locale](on-premises-instances-operations-remove-tags.md).
Per disinstallare automaticamente l' CodeDeploy agente e rimuovere il file di configurazione dall'istanza locale, vedere[Disinstalla automaticamente l' CodeDeploy agente e rimuovi il file di configurazione da un'istanza locale](on-premises-instances-operations-uninstall-agent.md).
Per disinstallare manualmente solo l' CodeDeploy agente dall'istanza locale, vedi. [Gestione delle operazioni degli CodeDeploy agenti](codedeploy-agent-operations.md)
Utilizzate il comando AWS CLI per chiamare il comando [deregister](https://docs.aws.amazon.com/cli/latest/reference/deploy/deregister.html), specificando:
+ Il nome che identifica in modo univoco l'istanza locale a CodeDeploy (con l'opzione). `--instance-name`
+ Facoltativamente, se eliminare l'utente IAM associato all'istanza locale. Il comportamento predefinito consiste nell'eliminare l'utente IAM. Se non si desidera eliminare l'utente IAM associato all'istanza locale, specificare l'opzione `--no-delete-iam-user` nel comando.
+ Facoltativamente, la AWS regione in cui è stata registrata l'istanza locale CodeDeploy (con l'`--region`opzione). Questa deve essere una delle regioni supportate elencate in [Regione e gli endpoint](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in *Riferimenti generali di AWS*(ad esempio,). `us-west-2` Se questa opzione non è specificata, verrà utilizzata la AWS regione predefinita associata all'utente IAM chiamante.
Un esempio di annullamento della registrazione di un'istanza ed eliminazione dell'utente:
```
aws deploy deregister --instance-name AssetTag12010298EX --region us-west-2
```
Un esempio di annullamento della registrazione di un'istanza senza eliminazione dell'utente:
```
aws deploy deregister --instance-name AssetTag12010298EX --no-delete-iam-user --region us-west-2
```
Il comando **deregister** funziona nel modo seguente:
1. Annulla la registrazione dell'istanza locale con. CodeDeploy
1. Se specificato, elimina l'utente IAM associato all'istanza locale.
Dopo aver annullato la registrazione di un'istanza locale:
+ L'istanza non viene più visualizzata nella console sin da subito.
+ È possibile creare immediatamente un'altra istanza con lo stesso nome.
Se questo comando rileva errori, viene visualizzato un messaggio di errore che descrive in che modo è possibile completare manualmente i passaggi rimanenti. In caso contrario, viene visualizzato un messaggio che descrive come chiamare il comando **uninstall**.
# Annulla manualmente la registrazione di un'istanza locale
Generalmente si annulla la registrazione di un'istanza locale quando non si ha più intenzione di distribuire in quell'istanza. Lo usi per annullare manualmente la AWS CLI registrazione delle istanze locali.
L'annullamento manuale della registrazione di un'istanza locale non comporta la disinstallazione dell'agente. CodeDeploy Non rimuove il file di configurazione dall'istanza. Non elimina l'utente IAM associato all'istanza. Non rimuove i tag associati all'istanza.
Per disinstallare automaticamente l' CodeDeploy agente e rimuovere il file di configurazione dall'istanza locale, consulta[Disinstalla automaticamente l' CodeDeploy agente e rimuovi il file di configurazione da un'istanza locale](on-premises-instances-operations-uninstall-agent.md).
Per disinstallare manualmente solo l' CodeDeploy agente, consulta[Gestione delle operazioni degli CodeDeploy agenti](codedeploy-agent-operations.md).
Per eliminare manualmente l'utente IAM associato, consulta [Eliminazione di un utente IAM dal tuo AWS account](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_DeletingUserFromAccount.html).
Per rimuovere manualmente solo i tag di istanze locali associati, consulta [Rimuovi manualmente i tag delle istanze locali da un'istanza locale](on-premises-instances-operations-remove-tags.md).
+ Chiamare il comando [deregister-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/deregister-on-premises-instance.html), specificando il nome che identifica in modo univoco l'istanza locale (con l'opzione `--instance-name`):
```
aws deploy deregister-on-premises-instance --instance-name AssetTag12010298EX
```
Dopo aver annullato la registrazione di un'istanza locale:
+ L'istanza non viene più visualizzata nella console sin da subito.
+ È possibile creare immediatamente un'altra istanza con lo stesso nome.
# Visualizza i dettagli dell'istanza con CodeDeploy
Puoi utilizzare la CodeDeploy console AWS CLI, la o la CodeDeploy APIs per visualizzare i dettagli sulle istanze utilizzate in una distribuzione.
Per informazioni sull'utilizzo delle azioni CodeDeploy API per visualizzare le istanze, consulta [GetDeploymentInstance[ListDeploymentInstances](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_ListDeploymentInstances.html)](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_GetDeploymentInstance.html), e. [ListOnPremisesInstances](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_ListOnPremisesInstances.html)
**Topics**
+ [Visualizza i dettagli dell'istanza (console)](#instances-view-details-console)
+ [Visualizza i dettagli dell'istanza (CLI)](#instances-view-details-cli)
## Visualizza i dettagli dell'istanza (console)
Per visualizzare i dettagli dell'istanza:
1. Accedi Console di gestione AWS e apri la CodeDeploy console all'indirizzo [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
**Nota**
Accedi con lo stesso utente che hai configurato. [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md)
1. Nel riquadro di navigazione, espandi **Deploy**, quindi scegli **Deployments**.
**Nota**
Se non viene visualizzata alcuna voce, assicurati che sia selezionata la regione corretta. Nella barra di navigazione, nel selettore di regione, scegli una delle regioni elencate in [Regione ed endpoint](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in. *Riferimenti generali di AWS* CodeDeploy è supportato solo in queste regioni.
1. Per visualizzare i dettagli di distribuzione, scegliere l'ID distribuzione per l'istanza.
1. È possibile visualizzare tutte le istanze nella sezione **Instance activity (Attività istanza)** della pagina della distribuzione.
1. Per visualizzare informazioni sui singoli eventi del ciclo di vita della distribuzione per un'istanza, nella pagina dei dettagli della distribuzione, nella colonna **Eventi**, scegli **Visualizza** eventi.
**Nota**
Se viene visualizzato **Failed** per uno qualsiasi degli eventi del ciclo di vita, nella pagina dei dettagli dell'istanza, scegli **Visualizza registri, **Visualizza**** in o entrambi. EC2 Suggerimenti per la risoluzione dei problemi sono disponibili in [Risoluzione dei problemi relativi alle istanze](troubleshooting-ec2-instances.md).
1. Se desideri visualizzare ulteriori informazioni su un' EC2 istanza Amazon, scegli l'ID dell'istanza nella colonna **ID istanza**.
## Visualizza i dettagli dell'istanza (CLI)
Per utilizzare l'opzione AWS CLI per visualizzare i dettagli dell'istanza, chiamate il `get-deployment-instance` comando o il `list-deployment-instances` comando.
Per visualizzare i dettagli relativi a una singola istanza, chiama il comando [get-deployment-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-instance.html) specificando:
+ L'ID distribuzione univoco. Per ottenere l'ID di distribuzione, chiamate il comando [list-deployments](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployments.html).
+ L'ID istanza univoco. Per ottenere l'ID istanza, chiama il comando [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html).
Per visualizzare un elenco delle IDs istanze utilizzate in una distribuzione, chiamate il comando, specificando: [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html)
+ L'ID distribuzione univoco. Per ottenere l'ID di distribuzione, chiama il comando [list-deployments](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployments.html).
+ Facoltativamente, se includere solo un'istanza IDs specifica in base al relativo stato di distribuzione. (Se non specificato, IDs verranno elencate tutte le istanze corrispondenti, indipendentemente dal loro stato di distribuzione.)
# CodeDeploy salute dell'istanza
CodeDeploy monitora lo stato di integrità delle istanze in un gruppo di distribuzione. Le distribuzioni non riescono se il numero di istanze integre è inferiore al numero minimo di istanze integre specificato per il gruppo di distribuzione durante la distribuzione. Ad esempio, se durante l'implementazione deve rimanere integro l'85% delle istanze e il gruppo di distribuzione contiene 10 istanze, è sufficiente che la distribuzione a una sola istanza non riesca per compromettere l'esito dell'intera distribuzione. Questo perché, già quando un'istanza viene portata offline per consentire l'installazione dell'ultima versione dell'applicazione, il numero di istanze integre disponibili scende a 90%. Pertanto, quando un'istanza non riesce e un'altra istanza è offline, solo l'80% delle istanze è integro e disponibile. CodeDeploy non riuscirà quindi a eseguire la distribuzione generale.
È importante ricordare che perché la distribuzione generale riesca, devono verificarsi le seguenti condizioni:
+ CodeDeploy è in grado di eseguire la distribuzione su ogni istanza della distribuzione.
+ La distribuzione ad almeno un'istanza ha esito positivo. Ciò significa che, anche se il valore minimo di istanze correttamente in esecuzione è 0, perché la distribuzione generale riesca, è necessario che la distribuzione di almeno una istanza abbia esito positivo (ovvero deve essere integra almeno un'istanza).
**Topics**
+ [Health status (Stato di integrità)](#instances-health-status)
+ [Informazioni sul numero minimo di istanze integre](#minimum-healthy-hosts)
+ [Circa il numero minimo di istanze integre per zona di disponibilità](#minimum-healthy-hosts-az)
## Health status (Stato di integrità)
CodeDeploy *assegna due valori di stato di integrità a ciascuna istanza: *integrità della revisione e integrità* dell'istanza.*
Integrità della revisione
L'integrità della revisione si basa sulla revisione dell'applicazione attualmente installata nell'istanza. Include i seguenti valori di stato:
+ Corrente: la revisione installata nell'istanza corrisponde alla revisione per l'ultima distribuzione riuscita del gruppo di distribuzione.
+ Precedente: la revisione installata nell'istanza corrisponde a una versione precedente dell'applicazione.
+ Sconosciuta: la revisione dell'applicazione non è stata installata con successo nell'istanza.
Stato dell'istanza
L'integrità dell'istanza si basa sulla riuscita o meno delle distribuzioni a un'istanza. Include i seguenti valori:
+ Integra: l'ultima distribuzione all'istanza ha avuto esito positivo.
+ Non integra: il tentativo di distribuire una revisione all'istanza ha avuto esito negativo o non è stata ancora distribuita una revisione all'istanza.
CodeDeploy utilizza l'integrità della revisione e lo stato dell'istanza per pianificare la distribuzione nelle istanze del gruppo di distribuzione nel seguente ordine:
1. Istanza non integra.
1. Integrità revisione sconosciuta.
1. Revisione precedente.
1. Revisione corrente.
Se la distribuzione complessiva ha esito positivo, la revisione viene aggiornata e i valori dello stato di integrità del gruppo di distribuzione vengono aggiornati per riflettere l'ultima distribuzione.
+ Un'istanza corrente interessata da una distribuzione riuscita mantiene lo stato corrente. In caso contrario, passa allo stato sconosciuta.
+ Un'istanza precedente o sconosciuta interessata da una distribuzione riuscita passa allo stato corrente. In caso contrario, mantiene lo stato precedente o sconosciuta.
+ Un'istanza integra interessata da una distribuzione riuscita mantiene lo stato integra. In caso contrario, passa allo stato non integra.
+ Un'istanza non integra interessata da una distribuzione riuscita passa allo stato integra. In caso contrario, mantiene lo stato non integra.
Se la distribuzione complessiva ha esito negativo o viene interrotta:
+ Per ogni istanza in cui si è CodeDeploy tentato di distribuire la revisione dell'applicazione lo stato dell'istanza è impostato su integro o non integro, a seconda che il tentativo di distribuzione per quell'istanza abbia avuto esito positivo o negativo.
+ Ogni istanza in cui non CodeDeploy ha tentato di distribuire la revisione dell'applicazione mantiene il valore di integrità dell'istanza corrente.
+ La revisione del gruppo di distribuzione resta la stessa.
## Informazioni sul numero minimo di istanze integre
Il numero minimo di istanze integre richiesto viene definito come parte di una configurazione della distribuzione.
**Importante**
Durante una blue/green distribuzione, la configurazione di distribuzione e il valore minimo degli host integri si applicano alle istanze nell'ambiente sostitutivo, non a quelle dell'ambiente originale. Tuttavia, quando viene annullata la registrazione delle istanze nell'ambiente originale dal sistema di bilanciamento del carico, la distribuzione complessiva viene contrassegnata come non riuscita anche se l'annullamento della registrazione non viene effettuato con successo per una sola istanza originale.
CodeDeploy fornisce tre configurazioni di distribuzione predefinite che utilizzano valori minimi di host integri di uso comune:
| Nome della configurazione di distribuzione predefinita | Valori minimi per host integri predefiniti |
| --- | --- |
| CodeDeployDefault.OneAtATime | 1 |
| CodeDeployDefault.HalfAtATime | 50% |
| CodeDeployDefault.AllAtOnce | 0 |
Ulteriori informazioni sulle configurazioni di distribuzione predefinite sono disponibili in [Utilizzo delle configurazioni di distribuzione in CodeDeploy](deployment-configurations.md).
È possibile creare configurazioni di distribuzione personalizzate CodeDeploy per definire i propri valori minimi di integrità dell'host. Puoi definire questi valori come numeri interi o percentuali quando utilizzi le seguenti operazioni:
+ Come `minimum-healthy-hosts` quando si utilizza il [create-deployment-config](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-config.html)comando in. AWS CLI
+ Come `Value` nel tipo di [MinimumHealthyHosts](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_MinimumHealthyHosts.html)dati nell' CodeDeploy API.
+ Come `MinimumHealthyHosts` quando si utilizza [AWS::CodeDeploy::DeploymentConfig](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codedeploy-deploymentconfig.html)in un CloudFormation modello.
CodeDeploy consente di specificare un numero minimo di istanze integre per la distribuzione per due scopi principali:
+ Per determinare se la distribuzione complessiva ha esito positivo o negativo. La distribuzione ha esito positivo se la revisione dell'applicazione è stata distribuita con successo ad almeno il numero minimo di istanze integre.
+ Per determinare il numero di istanze che devono essere integre durante una distribuzione affinché quest'ultima possa proseguire.
Puoi specificare il numero minimo di istanze integre per il tuo gruppo di distribuzione come numero di istanze o come percentuale del numero totale di istanze. Se si specifica una percentuale, all'inizio della distribuzione, CodeDeploy converte la percentuale nel numero equivalente di istanze, arrotondando per eccesso le istanze frazionarie.
CodeDeploy tiene traccia dello stato di integrità delle istanze del gruppo di distribuzione durante il processo di distribuzione e utilizza il numero minimo di istanze integre specificato per la distribuzione per determinare se continuare la distribuzione. Il principio di base è che una distribuzione non deve far mai scendere il numero di istanze integre al di sotto del valore minimo specificato. L'unica eccezione a questa regola può verificarsi quando un gruppo di distribuzione include inizialmente un numero minimo di istanze integre inferiore a quello minimo specificato. In quel caso, il processo di distribuzione non riduce ulteriormente il numero di istanze integre.
**Nota**
CodeDeploy tenterà di eseguire la distribuzione su tutte le istanze di un gruppo di distribuzione, anche su quelle attualmente in uno stato Interrotto. Nel calcolo del numero minimo di istanze integre, un'istanza interrotta ha lo stesso impatto di un'istanza non riuscita. Per risolvere il problema di distribuzioni non riuscite a causa di un numero eccessivo di istanze interrotte, riavvia le istanze o modificane i tag per escluderle dal gruppo di distribuzione.
CodeDeploy avvia il processo di distribuzione tentando di distribuire la revisione dell'applicazione sulle istanze non integre del gruppo di distribuzione. Per ogni distribuzione riuscita, CodeDeploy modifica lo stato di integrità dell'istanza in integro e la aggiunge alle istanze integre del gruppo di distribuzione. CodeDeploy quindi confronta il numero attuale di istanze integre con il numero minimo specificato di istanze integre.
+ Se il numero di istanze integre è inferiore o uguale al numero minimo specificato di istanze integre, CodeDeploy annulla la distribuzione per garantire che il numero di istanze integre non diminuisca con un numero maggiore di distribuzioni.
+ Se il numero di istanze integre è superiore al numero minimo specificato di istanze integre di almeno una, CodeDeploy distribuisce la revisione dell'applicazione nel set originale di istanze integre.
Se una distribuzione su un'istanza integra fallisce, CodeDeploy modifica lo stato di integrità dell'istanza in non integro. Man mano che la distribuzione procede, CodeDeploy aggiorna il numero attuale di istanze integre e lo confronta con il numero minimo specificato di istanze integre. Se il numero di istanze integre scende al numero minimo specificato in qualsiasi momento del processo di distribuzione, interrompe la distribuzione. CodeDeploy Questa misura previene la possibilità che la prossima distribuzione abbia esito negativo facendo scendere il numero di istanze integre al di sotto di quello minimo specificato.
**Nota**
Assicurati che il numero minimo di istanze integre che specifichi sia inferiore al numero totale di istanze nel gruppo di distribuzione. Se specifichi un valore percentuale, ricorda che verrà arrotondato. In caso contrario, quando la distribuzione viene avviata, il numero di istanze integre sarà già inferiore o uguale a quello minimo e CodeDeploy farà sì che la distribuzione complessiva abbia immediatamente esito negativo.
CodeDeploy utilizza inoltre il numero minimo specificato di istanze integre e il numero effettivo di istanze integre per determinare se e come distribuire la revisione dell'applicazione su più istanze. Per impostazione predefinita, CodeDeploy distribuisce la revisione dell'applicazione nel maggior numero possibile di istanze senza il rischio che il numero di istanze integre scenda al di sotto del numero minimo specificato di istanze integre.
Per determinare il numero di istanze su cui distribuire contemporaneamente, utilizza il seguente calcolo: CodeDeploy
```
[total-hosts] - [minimum-healthy-hosts] =
[number-of-hosts-to-deploy-to-at-once]
```
Esempio:
+ Se il gruppo di distribuzione ha 10 istanze e il numero minimo di istanze integre è impostato su 9, esegue la CodeDeploy distribuzione su 1 istanza alla volta.
+ Se il gruppo di distribuzione ha 10 istanze e il numero minimo di istanze integre è impostato su 3, CodeDeploy esegue la distribuzione su 7 istanze contemporaneamente nel primo batch e quindi sulle 3 rimanenti nel secondo batch.
+ Se il gruppo di distribuzione ha 10 istanze e il numero minimo di istanze integre è impostato su 0, esegue la CodeDeploy distribuzione su 10 istanze contemporaneamente.
**Esempi**
I seguenti esempi presuppongono un gruppo di distribuzione con 10 istanze.
Valore mimino di istanze integre: 95%
CodeDeploy arrotonda il numero minimo di istanze integre a 10 istanze, pari al numero di istanze integre. La distribuzione complessiva ha immediatamente esito negativo senza che la revisione venga distribuita ad alcuna istanza.
Valore mimino di istanze integre: 9
CodeDeploy distribuisce la revisione su un'istanza alla volta. Se la distribuzione su una delle istanze fallisce, fallisce CodeDeploy immediatamente l'implementazione complessiva perché il numero di istanze integre è uguale al numero minimo di istanze integre. Come eccezione a questa regola, se l'ultima istanza non riesce, la distribuzione ha comunque esito positivo.
CodeDeploy continua la distribuzione, un'istanza alla volta, fino a quando una distribuzione non fallisce o la distribuzione complessiva non viene completata. Se tutte e 10 le distribuzioni hanno esito positivo, il gruppo di distribuzione includerà 10 istanze integre.
Valore mimino di istanze integre: 8
CodeDeploy distribuisce la revisione su due istanze alla volta. Se due di queste distribuzioni falliscono, fallisce CodeDeploy immediatamente l'intera distribuzione. Come eccezione a questa regola, se l'ultima istanza è la seconda a non riuscire, la distribuzione complessiva avrà comunque esito positivo.
Valore mimino di istanze integre: 0
CodeDeploy distribuisce la revisione all'intero gruppo di distribuzione contemporaneamente. Almeno una distribuzione a un'istanza deve riuscire per far sì che la distribuzione complessiva abbia esito positivo. Se 0 istanze sono integre, la distribuzione ha esito negativo. Ciò è dovuto al requisito che, per contrassegnare una distribuzione complessiva come riuscita, almeno un'istanza deve essere integra al termine della distribuzione complessiva, anche se il valore minimo delle istanze integre è 0.
## Circa il numero minimo di istanze integre per zona di disponibilità
**Nota**
Questa sezione utilizza i termini *istanza* e *host* in modo intercambiabile per fare riferimento alle istanze Amazon EC2.
Se esegui la distribuzione su istanze in diverse [zone di disponibilità](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html#concepts-availability-zones), puoi facoltativamente abilitare la [zonal configuration](deployment-configurations-create.md#zonal-config) funzionalità, che consente la distribuzione in una zona di disponibilità CodeDeploy alla volta.
Quando questa funzionalità è abilitata, CodeDeploy farà in modo che il numero di host integri rimanga al di sopra dei valori «numero minimo di host integri per zona» *e* «numero minimo di host integri». Se il numero di host integri scende al di sotto di entrambi i valori, la distribuzione CodeDeploy non riesce in tutte le zone di disponibilità.
Per calcolare il numero di host su cui eseguire la distribuzione contemporaneamente, CodeDeploy utilizza sia il valore «numero minimo di host integri per zona» che il valore di «host integri minimi». CodeDeploy utilizzerà il *minor numero di calcoli `[A]` e, dove* e dove sono: `[B]` `[A]` `[B]`
```
[A] = [total-hosts] - [min-healthy-hosts] =
[number-of-hosts-to-deploy-to-at-once]
```
```
[B] = [total-hosts-per-AZ] - [min-healthy-hosts-per-AZ] =
[number-of-hosts-to-deploy-to-at-once-per-AZ]
```
Dopo aver determinato il numero di host su cui effettuare la distribuzione contemporaneamente, esegue la CodeDeploy distribuzione sugli host in batch composti da quel numero, una zona di disponibilità alla volta, con una pausa (o «tempo di cottura») opzionale tra le zone.
**Esempio**
Se la tua distribuzione è configurata in questo modo:
+ `[total-hosts]` è `200`
+ `[minimum-healthy-hosts]` è `160`
+ `[total-hosts-per-AZ]` è `100`
+ `[minimum-healthy-hosts-per-AZ]` è `50`
Allora...
+ `[A]` = `200 - 160 = 40`
+ `[B]` = `100 - 50 = 50`
+ `40`è inferiore a `50`
Pertanto, CodeDeploy verrà distribuito agli `40` host contemporaneamente.
In questo scenario, la distribuzione si svolge come segue:
1. CodeDeploy si distribuisce nella prima zona di disponibilità:
1. CodeDeploy viene distribuito sui primi `40` host.
1. CodeDeploy viene distribuito sugli host successivi`40`.
1. CodeDeploy viene distribuito sugli host `20` rimanenti.
La distribuzione nella prima zona di disponibilità è ora completa.
1. (Facoltativo) CodeDeploy attende che la distribuzione nella prima zona «riprenda», come definito dall'impostazione **Durata del monitoraggio** o **Aggiungi una durata del monitoraggio per la prima zona**. Se non ci sono problemi, CodeDeploy continua.
1. CodeDeploy si distribuisce nella seconda zona di disponibilità:
1. CodeDeploy viene distribuito sui primi `40` host.
1. CodeDeploy viene distribuito sugli host successivi`40`.
1. CodeDeploy viene distribuito sugli host `20` rimanenti.
La distribuzione nella seconda e ultima zona di disponibilità è ora completa.
Per ulteriori informazioni sulla funzionalità di configurazione zonale e su come specificare il numero minimo di istanze integre per zona di disponibilità, vedere. [zonal configuration](deployment-configurations-create.md#zonal-config)