AWS App Runner non sarà più aperto a nuovi clienti a partire dal 30 aprile 2026. Se desideri utilizzare App Runner, registrati prima di tale data. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta [AWS App Runner la pagina Modifica della disponibilità](https://docs.aws.amazon.com/apprunner/latest/dg/apprunner-availability-change.html).

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 della piattaforma Java
<a name="service-source-code-java"></a>

La piattaforma AWS App Runner Java fornisce runtime gestiti. Ogni runtime semplifica la creazione e l'esecuzione di contenitori con applicazioni Web basate su una versione Java. Quando si utilizza un runtime Java, App Runner inizia con un'immagine di runtime Java gestita. Questa immagine è basata sull'[immagine Docker di Amazon Linux](https://hub.docker.com/_/amazonlinux) e contiene il pacchetto di runtime per una versione di Java e alcuni strumenti. App Runner utilizza questa immagine di runtime gestita come immagine di base e aggiunge il codice dell'applicazione per creare un'immagine Docker. Quindi distribuisce questa immagine per eseguire il servizio Web in un contenitore.

 Si specifica un runtime per il servizio App Runner quando si [crea un servizio](manage-create.md) utilizzando la console App Runner o l'[CreateService](https://docs.aws.amazon.com/apprunner/latest/api/API_CreateService.html)operazione API. Puoi anche specificare un runtime come parte del codice sorgente. Usa la `runtime` parola chiave in un [file di configurazione di App Runner](config-file.md) che includi nel tuo repository di codice. La convenzione di denominazione di un runtime gestito è. *<language-name><major-version>* 

Al momento, tutti i runtime Java supportati sono basati su Amazon Corretto. Per nomi e versioni di runtime Java validi, consulta[Informazioni sulla release di Java Runtime](service-source-code-java-releases.md).

App Runner aggiorna il runtime del servizio alla versione più recente a ogni distribuzione o aggiornamento del servizio. Se l'applicazione richiede una versione specifica di un runtime gestito, è possibile specificarla utilizzando la `runtime-version` parola chiave nel file di [configurazione di App Runner](config-file.md). È possibile utilizzare qualsiasi livello di versione, inclusa una versione principale o secondaria. App Runner effettua solo aggiornamenti di livello inferiore al runtime del servizio.

Sintassi della versione per i runtime di Amazon Corretto:


| **Runtime** | **Sintassi** | **Esempio** | 
| --- | --- | --- | 
|  corretto11  |  `11.0[.openjdk-update[.openjdk-build[.corretto-specific-revision]]]`  |  `11.0.13.08.1`  | 
|  corretto8  |  `8[.openjdk-update[.openjdk-build[.corretto-specific-revision]]]`  |  `8.312.07.1`  | 

Gli esempi seguenti mostrano il blocco della versione:
+ `11.0.13`— Blocca la versione di aggiornamento di Open JDK. App Runner aggiorna solo le build di livello inferiore di Open JDK e Amazon Corretto.
+ `11.0.13.08.1`— Blocca a una versione specifica. App Runner non aggiorna la tua versione di runtime.

**Topics**
+ [Configurazione del runtime Java](#service-source-code-java.config)
+ [Esempi di runtime Java](#service-source-code-java.examples)
+ [Informazioni sulla release di Java Runtime](service-source-code-java-releases.md)

## Configurazione del runtime Java
<a name="service-source-code-java.config"></a>

Quando scegli un runtime gestito, devi anche configurare, come minimo, creare ed eseguire comandi. Li configuri durante la [creazione](manage-create.md) o [l'aggiornamento del](manage-configure.md) servizio App Runner. Puoi farlo utilizzando uno dei seguenti metodi:
+ **Utilizzo della console App Runner**: specifica i comandi nella sezione **Configure build** del processo di creazione o della scheda di configurazione.
+ **Utilizzo dell'API App Runner**: richiama l'operazione [CreateService](https://docs.aws.amazon.com/apprunner/latest/api/API_CreateService.html)or [UpdateService](https://docs.aws.amazon.com/apprunner/latest/api/API_UpdateService.html)API. Specificate i comandi utilizzando i `StartCommand` membri `BuildCommand` e del tipo di [CodeConfigurationValues](https://docs.aws.amazon.com/apprunner/latest/api/API_CodeConfigurationValues.html)dati.
+ **Utilizzo di un [file di configurazione](config-file.md)**: specifica uno o più comandi di compilazione in un massimo di tre fasi di compilazione e un singolo comando di esecuzione che serve per avviare l'applicazione. Sono disponibili impostazioni di configurazione opzionali aggiuntive.

Fornire un file di configurazione è facoltativo. Quando crei un servizio App Runner utilizzando la console o l'API, specifichi se App Runner ottiene le impostazioni di configurazione direttamente al momento della creazione o da un file di configurazione.

## Esempi di runtime Java
<a name="service-source-code-java.examples"></a>

Gli esempi seguenti mostrano i file di configurazione di App Runner per la creazione e l'esecuzione di un servizio Java. L'ultimo esempio è il codice sorgente di un'applicazione Java completa che è possibile distribuire su un servizio di runtime Corretto 11.

**Nota**  
La versione di runtime utilizzata in questi esempi è*11.0.13.08.1*. Puoi sostituirla con una versione che desideri utilizzare. Per l'ultima versione di runtime Java supportata, vedere[Informazioni sulla release di Java Runtime](service-source-code-java-releases.md).

### File di configurazione Minimal Corretto 11
<a name="service-source-code-java.examples.minimal"></a>

Questo esempio mostra un file di configurazione minimo che è possibile utilizzare con un runtime gestito di Corretto 11. Per le ipotesi che App Runner fa con un file di configurazione minimo, vedi.

**Example apprunner.yaml**  

```
version: 1.0
runtime: corretto11
build:
  commands:    
    build:
      - mvn clean package
run:                              
  command: java -Xms256m -jar target/MyApp-1.0-SNAPSHOT.jar .
```

### File di configurazione Corretto 11 esteso
<a name="service-source-code-java.examples.extended"></a>

Questo esempio mostra come utilizzare tutte le chiavi di configurazione con un runtime gestito di Corretto 11.

**Nota**  
La versione di runtime utilizzata in questi esempi è*11.0.13.08.1*. Puoi sostituirla con una versione che desideri utilizzare. Per l'ultima versione di runtime Java supportata, vedere[Informazioni sulla release di Java Runtime](service-source-code-java-releases.md).

**Example apprunner.yaml**  

```
version: 1.0
runtime: corretto11
build:
  commands:
    pre-build:
      - yum install some-package
      - scripts/prebuild.sh
    build:
      - mvn clean package
    post-build:
      - mvn clean test
  env:
    - name: M2
      value: "/usr/local/apache-maven/bin"
    - name: M2_HOME
      value: "/usr/local/apache-maven/bin"
run:
  runtime-version: 11.0.13.08.1
  command: java -Xms256m -jar target/MyApp-1.0-SNAPSHOT.jar .
  network:
    port: 8000
    env: APP_PORT
  env:
    - name: MY_VAR_EXAMPLE
      value: "example"
```

### Sorgente completo dell'applicazione Corretto 11
<a name="service-source-code-java.examples.end2end"></a>

Questo esempio mostra il codice sorgente di un'applicazione Java completa che è possibile distribuire su un servizio di runtime Corretto 11.

**Example src/main/java/com/HelloWorld/HelloWorld.java**  

```
package com.HelloWorld;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloWorld {

    @RequestMapping("/")
    public String index(){
        String s = "Hello World";
        return s;
    }
}
```

**Example src/main/java/com/HelloWorld/Main.java**  

```
package com.HelloWorld;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Main {

    public static void main(String[] args) {

        SpringApplication.run(Main.class, args);
    }
}
```

**Example apprunner.yaml**  

```
version: 1.0
runtime: corretto11
build:
  commands:    
    build:
      - mvn clean package
run:                              
  command: java -Xms256m -jar target/HelloWorldJavaApp-1.0-SNAPSHOT.jar .
  network:
    port: 8080
```

**Example pom.xml**  

```
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.1.RELEASE</version>
    <relativePath/>
  </parent>
  <groupId>com.HelloWorld</groupId>
  <artifactId>HelloWorldJavaApp</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <java.version>11</java.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-rest</artifactId>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
      <exclusions>
        <exclusion>
          <groupId>org.junit.vintage</groupId>
          <artifactId>junit-vintage-engine</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.0</version>
        <configuration>
          <release>11</release>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>
```

# Informazioni sulla release di Java Runtime
<a name="service-source-code-java-releases"></a>

Questo argomento elenca i dettagli completi per le versioni di runtime Java supportate da App Runner.


**Versioni di runtime supportate: build originale di App Runner**  
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/apprunner/latest/dg/service-source-code-java-releases.html)

**Nota**  
App Runner fornisce un processo di compilazione rivisto per i principali runtime specifici che sono stati rilasciati più di recente. Per questo motivo, in alcune sezioni di questo documento vedrai riferimenti alla build di *App Runner rivista e alla build* *originale di App Runner*. Per ulteriori informazioni, consulta [Versioni di runtime gestite e build di App Runner](service-source-code.md#service-source-code.build-detail).