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à.

# Aggiorna la versione di runtime nel file buildspec
<a name="sample-runtime-update-version"></a>

Puoi modificare il runtime utilizzato dal tuo progetto con una nuova versione aggiornando la `runtime-versions` sezione del tuo file buildspec. I seguenti esempi mostrano come specificare le versioni 8 e 11 di Java:
+ Una sezione `runtime-versions` che specifica la versione 8 di Java:

  ```
  phases:
    install:
      runtime-versions:
        java: corretto8
  ```
+ Una sezione `runtime-versions` che specifica la versione 11 di Java:

  ```
  phases:
    install:
      runtime-versions:
        java: corretto11
  ```

I seguenti esempi mostrano come specificare diverse versioni di Python usando l'immagine standard di Ubuntu 5.0 o l'immagine standard di Amazon Linux 2 3.0:
+ Una `runtime-versions` sezione che specifica la versione 3.7 di Python: 

  ```
  phases:
    install:
      runtime-versions:
        python: 3.7
  ```
+ Una `runtime-versions` sezione che specifica la versione 3.8 di Python: 

  ```
  phases:
    install:
      runtime-versions:
        python: 3.8
  ```

Questo esempio illustra un progetto che inizia con il runtime Java versione 8 e viene aggiornato al runtime Java versione 10. 

1. Scaricare e installare Maven. Per informazioni, consultare le pagine del sito Web di Apache Maven relative al [download di Apache Maven](https://maven.apache.org/download.cgi) e all'[installazione di Apache Maven](https://maven.apache.org/install.html).

1. Passare a una directory vuota sull'istanza o sul computer locale, quindi eseguire il comando Maven.

   ```
   mvn archetype:generate "-DgroupId=com.mycompany.app" "-DartifactId=ROOT" "-DarchetypeArtifactId=maven-archetype-webapp" "-DinteractiveMode=false"
   ```

   Se il comando è eseguito correttamente, vengono creati la struttura e i file della directory.

   ```
   .
   └── ROOT
       ├── pom.xml
       └── src
           └── main
               ├── resources
               └── webapp
                   ├── WEB-INF
                   │   └── web.xml
                   └── index.jsp
   ```

1. Crea un file denominato `buildspec.yml` con i seguenti contenuti. Archivia il file nella directory ` (root directory name)/my-web-app`. 

   ```
   version: 0.2
   
   phases:
     install:
       runtime-versions:
         java: corretto8
     build:
       commands:
         - java -version
         - mvn package
   artifacts:
     files:
       - '**/*'
     base-directory: 'target/my-web-app'
   ```

   Nel file buildspec: 
   + La sezione `runtime-versions` specifica che il progetto utilizza la versione 8 del runtime Java . 
   + Il comando `- java -version` visualizza la versione di Java utilizzata dal progetto al momento della compilazione. 

   La struttura del file dovrebbe avere il seguente aspetto. 

   ```
   (root directory name)
   └── my-web-app
       ├── src
       │   ├── main
       │   ├── resources
       │   └── webapp
       │       └── WEB-INF
       │           └── web.xml
       │               └── index.jsp
       ├── buildspec.yml
       └── pom.xml
   ```

1. Carica il contenuto della `my-web-app` directory in un bucket di input S3 o in un repository CodeCommit, GitHub o Bitbucket. 
**Importante**  
Non caricare `(root directory name)` o `(root directory name)/my-web-app`, ma solo le directory e i file all'interno di `(root directory name)/my-web-app`.   
Se si sta usando un bucket di input S3, assicurarsi di creare un file ZIP che contenga la struttura e i file della directory, quindi caricarlo nel bucket di input. Non aggiungere `(root directory name)` o `(root directory name)/my-web-app` al file ZIP, ma solo le directory e i file all'interno di `(root directory name)/my-web-app`.

1. [Apri la console su codebuild/home. AWS CodeBuild https://console.aws.amazon.com/codesuite/](https://console.aws.amazon.com/codesuite/codebuild/home)

1. Creare un progetto di compilazione. Per ulteriori informazioni, consultare [Creare un progetto di compilazione (console)](create-project.md#create-project-console) e [Esecuzione di una compilazione (console)](run-build-console.md). Lasciare tutte le impostazioni sui valori predefiniti, ad eccezione delle seguenti.
   + In **Environment (Ambiente)**:
     + Per **Environment image (Immagine ambiente)**, scegliere **Managed image (Immagine gestita)**.
     + Per **Operating system (Sistema operativo)**, scegliere **Amazon Linux 2**. 
     +  In **Runtime(s) (Runtime)**, seleziona **Standard**. 
     + **Per **Image**, scegli -x86\$164-standard:4.0. aws/codebuild/amazonlinux**

1. Selezionare **Start build (Avvia compilazione)**. 

1. In **Build configuration (Configurazione della compilazione)** accettare le impostazioni predefinite, quindi scegliere **Build configuration (Avvia compilazione)**. 

1. Al termine della compilazione, visualizzare l’output della compilazione nella scheda **Build logs (Log di compilazione)**. Verrà visualizzato un output simile al seguente: 

   ```
   [Container] Date Time Phase is DOWNLOAD_SOURCE
   [Container] Date Time CODEBUILD_SRC_DIR=/codebuild/output/src460614277/src
   [Container] Date Time YAML location is /codebuild/output/src460614277/src/buildspec.yml
   [Container] Date Time Processing environment variables
   [Container] Date Time Selecting 'java' runtime version 'corretto8' based on manual selections...
   [Container] Date Time Running command echo "Installing Java version 8 ..."
   Installing Java version 8 ... 
    
   [Container] Date Time Running command export JAVA_HOME="$JAVA_8_HOME" 
    
   [Container] Date Time Running command export JRE_HOME="$JRE_8_HOME" 
    
   [Container] Date Time Running command export JDK_HOME="$JDK_8_HOME" 
    
   [Container] Date Time Running command for tool_path in "$JAVA_8_HOME"/bin/* "$JRE_8_HOME"/bin/*;
   ```

1. Aggiorna la sezione `runtime-versions` con Java versione 11: 

   ```
   install:
       runtime-versions:
         java: corretto11
   ```

1. Dopo aver salvato la modifica, esegui nuovamente la compilazione e visualizza l’output di compilazione. La versione di Java installata visualizzata è 11. Verrà visualizzato un output simile al seguente: 

   ```
   [Container] Date Time Phase is DOWNLOAD_SOURCE
   [Container] Date Time CODEBUILD_SRC_DIR=/codebuild/output/src460614277/src
   [Container] Date Time YAML location is /codebuild/output/src460614277/src/buildspec.yml
   [Container] Date Time Processing environment variables
   [Container] Date Time Selecting 'java' runtime version 'corretto11' based on manual selections... 
   Installing Java version 11 ... 
    
   [Container] Date Time Running command export JAVA_HOME="$JAVA_11_HOME" 
    
   [Container] Date Time Running command export JRE_HOME="$JRE_11_HOME" 
    
   [Container] Date Time Running command export JDK_HOME="$JDK_11_HOME" 
    
   [Container] Date Time Running command for tool_path in "$JAVA_11_HOME"/bin/* "$JRE_11_HOME"/bin/*;
   ```