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à.
# Configurazione dell'interfaccia a riga di comando EB (EB CLI) per gestire Elastic Beanstalk
L'EB CLI è un'interfaccia a riga di comando che fornisce comandi interattivi per creare, aggiornare e monitorare ambienti. AWS Elastic Beanstalk Il progetto open source EB CLI è su Github: `[aws/aws-elastic-beanstalk-cli](https://github.com/aws/aws-elastic-beanstalk-cli)`
Dopo aver installato l'interfaccia a riga di comando EB e aver configurato una directory di progetto, puoi creare ambienti con un singolo comando:
```
$ eb create my-beanstalk-environment
```
Ti consigliamo di installarlo con lo script di configurazione, scopri come farlo. [Installa EB CLI con lo script di configurazione (consigliato)](#eb-cli3-install)
AWS CLI Fornisce accesso diretto a Elastic APIs Beanstalk di basso livello. Sebbene potente, è anche prolisso e meno preferito rispetto alla CLI EB. Ad esempio, la creazione di un ambiente con AWS CLI richiede la seguente serie di comandi:
```
$ aws elasticbeanstalk check-dns-availability \
--cname-prefix my-cname
$ aws elasticbeanstalk create-application-version \
--application-name my-application \
--version-label v1 \
--source-bundle S3Bucket=amzn-s3-demo-bucket,S3Key=php-proxy-sample.zip
$ aws elasticbeanstalk create-environment \
--cname-prefix my-cname \
--application-name my-app \
--version-label v1 \
--environment-name my-env \
--solution-stack-name "64bit Amazon Linux 2023 v4.5.0 running Ruby 3.4"
```
## Installa EB CLI con lo script di configurazione (consigliato)
**Consigliamo lo script di installazione**
Si consiglia di utilizzare lo script di installazione per configurare l'EB CLI e le sue dipendenze e prevenire potenziali conflitti con altri pacchetti Python.
[Prerequisiti: Git, Python e virtualenv](https://virtualenv.pypa.io/en/latest/installation.html)
**Per scaricare e utilizzare lo script di installazione**
1. Clonare il repository.
```
git clone https://github.com/aws/aws-elastic-beanstalk-cli-setup.git
```
1. Installa o aggiorna l'EB CLI.
**macOS/Linux** in Bash o Zsh
```
python ./aws-elastic-beanstalk-cli-setup/scripts/ebcli_installer.py
```
**Windows nella nostra finestra** di comando PowerShell
```
python .\aws-elastic-beanstalk-cli-setup\scripts\ebcli_installer.py
```
1. Verifica che l'interfaccia a riga di comando EB sia installata correttamente.
```
$ eb --version
EB CLI 3.21.0 (Python 3.12)
```
Per istruzioni complete sull'installazione, consulta il [https://github.com/aws/aws-elastic-beanstalk-cli-setup](https://github.com/aws/aws-elastic-beanstalk-cli-setup)repository su GitHub.
## Installazione manuale dell'interfaccia a riga di comando EB
Puoi installare l'EB CLI su Linux, macOS e Windows con il `pip` gestore di pacchetti per Python che fornisce l'installazione, l'aggiornamento e la rimozione dei pacchetti Python e delle loro dipendenze.
**Consigliamo lo script di installazione**
Si consiglia di utilizzare il [Installa EB CLI](#eb-cli3-install) per configurare l'EB CLI e prevenire i conflitti di dipendenza.
**Prerequisito**: è necessario che sia installata una versione supportata di Python. Puoi scaricarlo dalla pagina dei [download di Python](https://www.python.org/downloads/) sul sito Web di Python.
**Per installare l'EB CLI (manualmente)**
1. Eseguire il seguente comando seguente.
```
$ pip install awsebcli --upgrade --user
```
L'opzione `--upgrade` indica a `pip` di aggiornare i requisiti già installati. L'opzione `--user` indica a `pip` di installare il programma in una sottodirectory della directory utente per evitare di modificare le librerie utilizzate dal sistema operativo.
**Risoluzione dei problemi**
Se si verificano problemi quando si tenta di installare l'interfaccia a riga di comando EB con `pip`, è possibile [installare l'interfaccia a riga di comando EB in un ambiente virtuale](#eb-cli3-install-virtualenv) per isolare lo strumento e le relative dipendenze oppure utilizzare una versione di Python diversa da quella utilizzata normalmente.
1. Aggiungi il percorso dell'eseguibile alla variabile `PATH`:
+ Su Linux e macOS:
**Linux** – `~/.local/bin`
**macOS** – `~/Library/Python/3.12/bin`
Per modificare la variabile `PATH` (Linux, Unix o macOS):
1. Trova lo script del profilo della tua shell nella tua cartella utente. Se non sei sicuro di quale sia la tua shell, esegui `echo $SHELL`.
```
$ ls -a ~
. .. .bash_logout .bash_profile .bashrc Desktop Documents Downloads
```
+ **Bash** – `.bash_profile`, `.profile` o `.bash_login`.
+ **Zsh** - `.zshrc`
+ **Tcsh** – `.tcshrc`, `.cshrc` o `.login`.
1. Aggiungi un comando di esportazione allo script del tuo profilo. L'esempio seguente aggiunge il percorso rappresentato da *LOCAL\$1PATH* alla `PATH` variabile corrente.
```
export PATH=LOCAL_PATH:$PATH
```
1. Carica lo script del profilo descritto nella prima fase nella sessione corrente. L'esempio seguente carica lo script di profilo rappresentato da*PROFILE\$1SCRIPT*.
```
$ source ~/PROFILE_SCRIPT
```
+ In Windows:
**Python 3.12** — `%USERPROFILE%\AppData\Roaming\Python\Python312\Scripts`
**Versioni precedenti di Python** – `%USERPROFILE%\AppData\Roaming\Python\Scripts`
Per modificare la variabile `PATH` (Windows):
1. Premi il tasto Windows, quindi digita **environment variables**.
1. Seleziona **Edit environment variables for your account (Modifica variabili di ambiente per l'account)**.
1. Seleziona **PATH (PERCORSO)**, quindi **Edit (Modifica)**.
1. Aggiungi percorsi nel campo **Variable value (Valore variabile)**, separati da punto e virgola. Ad esempio: `C:\item1\path;C:\item2\path`
1. Fai doppio clic su **OK** per applicare le nuove impostazioni.
1. Chiudi tutte le finestre del prompt dei comandi in esecuzione, quindi riapri una finestra del prompt dei comandi.
1. Verifica che l'interfaccia a riga di comando EB sia installata correttamente eseguendo **eb --version**.
```
$ eb --version
EB CLI 3.21.0 (Python 3.12)
```
L'interfaccia a riga di comando EB viene aggiornata regolarmente per aggiungere funzionalità che supportano le caratteristiche [più recenti di Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/). Per eseguire l'aggiornamento alla versione più recente dell'interfaccia a riga di comando EB, esegui nuovamente il comando di installazione.
```
$ pip install awsebcli --upgrade --user
```
Se devi disinstallare l'interfaccia a riga di comando EB, usa `pip uninstall`.
```
$ pip uninstall awsebcli
```
## Installazione dell'interfaccia a riga di comando EB in un ambiente virtuale
È possibile evitare conflitti di versione dei requisiti con altri pacchetti `pip` installando l'interfaccia a riga di comando EB in un ambiente virtuale.
**Per installare l'interfaccia a riga di comando EB in un ambiente virtuale**
1. Innanzitutto, installa con. `virtualenv` `pip`
```
$ pip install --user virtualenv
```
1. Crea un ambiente virtuale.
```
$ virtualenv ~/eb-ve
```
Utilizza l'opzione `-p` per usare un eseguibile Python diverso da quello predefinito.
```
$ virtualenv -p /usr/bin/python3.12 ~/eb-ve
```
1. Attiva l'ambiente virtuale.
**Linux, Unix o macOS**
```
$ source ~/eb-ve/bin/activate
```
**Windows**
```
$ %USERPROFILE%\eb-ve\Scripts\activate
```
1. Installa l'interfaccia a riga di comando EB.
```
(eb-ve)$ pip install awsebcli --upgrade
```
1. Verifica che l'interfaccia a riga di comando EB sia installata correttamente.
```
$ eb --version
EB CLI 3.23.0 (Python 3.12)
```
Puoi utilizzare il comando `deactivate` per chiudere l'ambiente virtuale. Ogni volta che avvii una nuova sessione, esegui di nuovo il comando di attivazione.
Per eseguire l'upgrade alla versione più recente, esegui nuovamente il comando di installazione.
```
(eb-ve)$ pip install awsebcli --upgrade
```
## Installazione dell'interfaccia a riga di comando EB con Homebrew
La versione più recente dell'interfaccia a riga di comando EB è generalmente disponibile da `Homebrew` un paio di giorni dopo che appare in `pip`.
**Consigliamo lo script di installazione**
Si consiglia di utilizzare il [Installa EB CLI](#eb-cli3-install) per configurare l'EB CLI e prevenire i conflitti di dipendenza.
**Per installare l'interfaccia a riga di comando EB con `Homebrew`**
1. Accertati di disporre della versione più recente di `Homebrew`.
```
$ brew update
```
1. Esegui `brew install awsebcli`.
```
$ brew install awsebcli
```
1. Verifica che l'interfaccia a riga di comando EB sia installata correttamente.
```
$ eb --version
EB CLI 3.21.0 (Python 3.12)
```
# Configurazione dell'interfaccia a riga di comando EB
Dopo aver [installato l'EB CLI](eb-cli3.md#eb-cli3-install), siete pronti per configurare la directory del progetto e l'EB CLI eseguendola**eb init**. L'esempio seguente mostra i passaggi di configurazione quando si esegue **eb init** per la prima volta in una cartella di progetto denominata. `eb`
**Per inizializzare un progetto dell'interfaccia a riga di comando EB**
1. In primo luogo, l'interfaccia a riga di comando EB ti chiede di selezionare una regione. Scegli la tua regione preferita.
```
~/eb $ eb init
Select a default region
1) us-east-1 : US East (N. Virginia)
2) us-west-1 : US West (N. California)
3) us-west-2 : US West (Oregon)
4) eu-west-1 : Europe (Ireland)
5) eu-central-1 : Europe (Frankfurt)
6) ap-south-1 : Asia Pacific (Mumbai)
7) ap-southeast-1 : Asia Pacific (Singapore)
...
(default is 3): 3
```
1. Se richiesto, fornisci la tua chiave di accesso e la chiave segreta in modo che l'EB CLI possa gestire le risorse per te. Le chiavi di accesso vengono create nella AWS Identity and Access Management console. Se non disponi delle chiavi, consulta l'argomento che descrive [come ottenere le credenziali di sicurezza](https://docs.aws.amazon.com/general/latest/gr/getting-aws-sec-creds.html) in *Riferimenti generali di Amazon Web Services*.
```
You have not yet set up your credentials or your credentials are incorrect.
You must provide your credentials.
(aws-access-id): AKIAJOUAASEXAMPLE
(aws-secret-key): 5ZRIrtTM4ciIAvd4EXAMPLEDtm+PiPSzpoK
```
1. Un'applicazione Elastic Beanstalk è una risorsa che contiene un set di versioni dell'applicazione (origine), ambienti e configurazioni salvate associati a una singola applicazione Web. Ogni volta che distribuisci il codice sorgente per Elastic Beanstalk utilizzando la CLI EB, una nuova versione dell'applicazione viene creata e aggiunta all'elenco.
```
Select an application to use
1) [ Create new Application ]
(default is 1): 1
```
1. Il nome predefinito dell'applicazione è il nome della cartella in cui esegui **eb init**. Inserisci un nome che descrive il tuo progetto.
```
Enter Application Name
(default is "eb"): eb
Application eb has been created.
```
1. Seleziona una piattaforma che corrisponda al framework o al linguaggio con cui è stata sviluppata la tua applicazione Web. Se non hai iniziato a sviluppare un'applicazione, scegli una piattaforma che ti interessa. Visualizzerai come avviare un'applicazione di esempio a breve, e puoi sempre modificare questa impostazione in un secondo momento.
```
Select a platform.
1) .NET Core on Linux
2) .NET on Windows Server
3) Docker
4) Go
5) Java
6) Node.js
7) PHP <== select platform by number
8) Packer
9) Python
10) Ruby
11) Tomcat
(make a selection):7
```
1. Seleziona un ramo specifico della piattaforma.
```
Select a platform branch.
1) PHP 8.4 running on 64bit Amazon Linux 2023
2) PHP 8.3 running on 64bit Amazon Linux 2023
3) PHP 8.2 running on 64bit Amazon Linux 2023
4) PHP 8.1 running on 64bit Amazon Linux 2023
5) PHP 8.1 running on 64bit Amazon Linux 2
(default is 1):1
```
1. Scegli **yes (sì)** per assegnare una coppia di chiavi SSH alle istanze nel tuo ambiente Elastic Beanstalk. In questo modo ci si connette direttamente per la risoluzione dei problemi.
```
Do you want to set up SSH for your instances?
(y/n): y
```
1. Seleziona una coppia di chiavi esistente o creane una nuova. Per utilizzare **eb init** per creare una nuova coppia di chiavi, **ssh-keygen** deve essere installato nel computer locale e disponibile dalla riga di comando. L'EB CLI registra EC2 per te la nuova coppia di chiavi con Amazon e archivia la chiave privata localmente in una cartella denominata `.ssh` nella tua directory utente.
```
Select a keypair.
1) [ Create new KeyPair ]
(default is 1): 1
```
L'installazione dell'interfaccia a riga di comando EB è ora configurata e pronta all'uso.
**Topics**
+ [File ignorati con .ebignore](#eb-cli3-ebignore)
+ [Utilizzo di profili denominati](#eb-cli3-profile)
+ [Distribuzione di artifact invece della cartella del progetto](#eb-cli3-artifact)
+ [Impostazioni di configurazione e precedenza](#eb-cli3-credentials)
+ [Metadati delle istanze](#eb-cli3-metadata)
## File ignorati con .ebignore
Puoi stabilire che l'interfaccia a riga di comando EB ignori alcuni file nella directory di progetto aggiungendo il file `.ebignore` alla directory. Questo file funziona come un file `.gitignore`. Quando distribuisci la directory del progetto in Elastic Beanstalk e crei una nuova versione dell'applicazione, la CLI EB non include i file specificati da `.ebignore` nel bundle di origine creato.
Se `.ebignore` non è presente ma è disponibile `.gitignore`, l'interfaccia a riga di comando EB ignora i file specificati in `.gitignore`. Se `.ebignore` è presente, l'interfaccia a riga di comando EB non legge `.gitignore`.
Quando `.ebignore` è presente, l'interfaccia a riga di comando EB non utilizza i comandi git per creare il bundle di origine. Questo significa che la CLI EB ignora i file specificati in `.ebignore` e include tutti gli altri file. In particolare, include i file sorgente non eseguiti.
**Nota**
In Windows, se aggiungi `.ebignore`, l'interfaccia a riga di comando EB segue i collegamenti simbolici e include il file collegato durante la creazione di un bundle di origine. Si tratta di un problema noto e verrà risolto in un aggiornamento futuro.
## Utilizzo di profili denominati
Se archivi le credenziali come un profilo denominato in un file `credentials` o `config`, puoi utilizzare l'opzione [`--profile`](eb3-cmd-options.md) per specificare un profilo in modo esplicito. Ad esempio, il comando seguente crea una nuova applicazione utilizzando il profilo `user2`.
```
$ eb init --profile user2
```
Puoi inoltre modificare il profilo predefinito impostando la variabile di ambiente `AWS_EB_PROFILE`. Quando questa variabile è impostata, l'interfaccia a riga di comando EB legge le credenziali del profilo specificato anziché `default` o **eb-cli**.
**Linux, macOS o Unix**
```
$ export AWS_EB_PROFILE=user2
```
**Windows**
```
> set AWS_EB_PROFILE=user2
```
## Distribuzione di artifact invece della cartella del progetto
Puoi chiedere all'interfaccia a riga di comando EB di distribuire un file WAR o ZIP generato come parte di un processo di creazione separato aggiungendo le seguenti righe `.elasticbeanstalk/config.yml` alla cartella del tuo progetto.
```
deploy:
artifact: path/to/buildartifact.zip
```
Se configuri l'interfaccia a riga di comando EB nel tuo [archivio Git](eb3-cli-git.md) e non esegui il commit dell'artefatto all'origine, utilizza l'opzione `--staged` per distribuire la compilazione più recente.
```
~/eb$ eb deploy --staged
```
## Impostazioni di configurazione e precedenza
L'EB CLI utilizza una *catena di provider* per cercare AWS le credenziali in diversi punti, tra cui variabili di ambiente di sistema o utente e file di configurazione locali AWS .
L'interfaccia a riga di comando EB cerca le credenziali e le impostazioni di configurazione nell'ordine seguente:
1. **Opzioni della riga di comando**: specifica un profilo denominato utilizzando `--profile` per sovrascrivere le impostazioni predefinite.
1. **Variabili di ambiente**: `AWS_ACCESS_KEY_ID` e `AWS_SECRET_ACCESS_KEY`.
1. **Il file AWS delle credenziali**: si trova `~/.aws/credentials` nei sistemi Linux e OS X o nei sistemi Windows. `C:\Users\USERNAME\.aws\credentials` Questo file può contenere più profili denominati in aggiunta a un profilo predefinito.
1. **[File di configurazione della AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html#cli-config-files)**: disponibile nei `~/.aws/config` sistemi Linux e OS X o nei `C:\Users\USERNAME\.aws\config` sistemi Windows. Questo file può contenere un profilo predefinito, [profili denominati](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html#cli-multiple-profiles) e parametri di configurazione AWS CLI specifici per ciascuno di essi.
1. **File di configurazione legacy della CLI EB**: disponibile in `~/.elasticbeanstalk/config` nei sistemi Linux e OS X o in `C:\Users\USERNAME\.elasticbeanstalk\config` nei sistemi Windows.
1. **Credenziali del profilo di istanza**: queste credenziali possono essere utilizzate su EC2 istanze Amazon con un ruolo di istanza assegnato e vengono fornite tramite il servizio di metadati Amazon EC2 . Il [profilo dell'istanza](concepts-roles-instance.md) deve disporre delle autorizzazioni per utilizzare Elastic Beanstalk.
Se il file delle credenziali contiene un profilo denominato con il nome "eb-cli", l'interfaccia a riga di comando EB preferirà quel profilo al profilo predefinito. Se non vengono trovati profili o viene trovato un profilo che non dispone delle autorizzazioni per utilizzare Elastic Beanstalk, la CLI EB richiede di immettere le chiavi.
## Metadati delle istanze
Per utilizzare l'EB CLI da un' EC2 istanza Amazon, crea un ruolo che abbia accesso alle risorse necessarie e assegna quel ruolo all'istanza quando viene lanciata. Avvia l'istanza e installa l'interfaccia a riga di comando di EB utilizzando `pip`.
```
~$ sudo pip install awsebcli
```
`pip` è preinstallato su Amazon Linux.
L'interfaccia a riga di comando di EB legge le credenziali dai metadata dell'istanza. Per ulteriori informazioni, consulta [Concedere alle applicazioni eseguite su Amazon EC2 Instances l'accesso alle AWS risorse](https://docs.aws.amazon.com/IAM/latest/UserGuide/role-usecase-ec2app.html) nella *IAM User Guide*.
# Utilizzo dell'interfaccia a riga di comando EB con Git
L'EB CLI fornisce un'integrazione Git che consente di associare rami di codice a ambienti specifici in Elastic Beanstalk per organizzare le distribuzioni.
**Per installare Git e inizializzare il tuo repository Git**
1. Scarica la versione più recente di Git dal sito [http://git-scm.com](http://git-scm.com).
1. Inizializza il tuo repository Git digitando quanto segue:
```
~/eb$ git init
```
Ora l'interfaccia a riga di comando EB riconoscerà che la tua applicazione è configurata con Git.
1. Se non hai già eseguito **eb init**, fallo adesso:
```
~/eb$ eb init
```
## Associazione di ambienti Elastic Beanstalk ai rami Git
Puoi associare un ambiente diverso a ogni ramo del codice. Quando esegui il checkout di un ramo, le modifiche vengono distribuite all'ambiente associato. Ad esempio, puoi digitare quanto segue per associare il tuo ambiente di produzione al ramo principale e un ambiente di sviluppo separato al ramo di sviluppo:
```
~/eb$ git checkout mainline
~/eb$ eb use prod
~/eb$ git checkout develop
~/eb$ eb use dev
```
## Distribuzione di modifiche
Per impostazione predefinita, l'interfaccia a riga di comando EB distribuisce il commit più recente nel ramo attuale, utilizzando l'ID di commit e il messaggio rispettivamente come etichetta di versione dell'applicazione e descrizione. Se desideri eseguire la distribuzione nel tuo ambiente senza impegnarti, puoi utilizzare l'opzione `--staged` per distribuire le modifiche aggiunte all'area di gestione temporanea.
**Per distribuire le modifiche senza eseguire il commit**
1. Aggiungi file nuovi e modificati all'area di gestione temporanea:
```
~/eb$ git add .
```
1. Distribuisci le modifiche per fasi con **eb deploy**:
```
~/eb$ eb deploy --staged
```
Se hai configurato l'interfaccia a riga di comando EB per [distribuire un artefatto](eb-cli3-configuration.md#eb-cli3-artifact) e non esegui il commit dell'artefatto al tuo repository git, utilizza l'opzione `--staged` per distribuire la build più recente.
## Utilizzo di moduli secondari Git
Alcuni progetti di codice traggono vantaggio dalla disponibilità di moduli secondari Git, repository all'interno del repository di primo livello. Quando distribuisci il tuo codice utilizzando **eb create** o **eb deploy**, l'interfaccia a riga di comando EB può includere moduli secondari nel file zip della versione dell'applicazione e caricarli con il resto del codice.
Puoi controllare l'inclusione di moduli secondari utilizzando l'opzione `include_git_submodules` nella sezione `global` del file di configurazione dell'interfaccia a riga di comando EB, `.elasticbeanstalk/config.yml` nella tua cartella di progetto.
Per includere moduli secondari, impostare questa opzione su `true`:
```
global:
include_git_submodules: true
```
Quando l'opzione `include_git_submodules` è mancante o è impostata su `false`, l'interfaccia a riga di comando EB non include moduli secondari nel file .zip caricato.
Per ulteriori dettagli sui moduli secondari Git, vedi [Git Tools - Submodules](https://git-scm.com/book/en/v2/Git-Tools-Submodules).
**Comportamento predefinito**
Quando esegui **eb init** per configurare il tuo progetto, l'interfaccia a riga di comando EB aggiunge l'opzione `include_git_submodules` e la impostata su `true`. Questo garantisce che eventuali moduli secondari del progetto siano inclusi nelle distribuzioni.
L'interfaccia a riga di comando EB non sempre supporta l'inclusione di moduli secondari. Per evitare una modifica accidentale e indesiderabile dei progetti, esistita prima che aggiungessimo il supporto dei moduli secondari, l'interfaccia a riga di comando EB non include moduli secondari quando l'opzione `include_git_submodules` è mancante. Se disponi di uno di questi progetti esistenti e desideri includere moduli secondari nelle tue distribuzioni, aggiungi l'opzione e impostala su `true` come descritto in questa sezione.
**CodeCommit comportamento**
L'integrazione di Elastic Beanstalk con CodeCommit non supporta i sottomoduli in questo momento. Se hai abilitato l'integrazione con il tuo ambiente CodeCommit, i sottomoduli non sono inclusi nelle distribuzioni.
## Assegnazione di tag Git alla tua versione dell'applicazione
Puoi utilizzare un tag Git come etichetta di versione per identificare la versione dell'applicazione in esecuzione nel tuo ambiente. Ad esempio, digita quanto segue:
```
~/eb$ git tag -a v1.0 -m "My version 1.0"
```