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

# Distribuzione di applicazioni Java con Elastic Beanstalk
<a name="create_deploy_Java"></a>

Questo capitolo fornisce istruzioni per configurare e distribuire le applicazioni Java su. AWS Elastic Beanstalk Elastic Beanstalk semplifica la distribuzione, la gestione e la scalabilità delle applicazioni Web Java utilizzando Amazon Web Services.

Puoi distribuire la tua applicazione in pochi minuti utilizzando l'Elastic Beanstalk Command Line Interface (EB CLI) o utilizzando la console Elastic Beanstalk. Dopo aver distribuito l'applicazione Elastic Beanstalk, puoi continuare a utilizzare l'EB CLI per gestire l'applicazione e l'ambiente, oppure puoi utilizzare la console Elastic Beanstalk o il. AWS CLI APIs

Segui le step-by-step istruzioni [QuickStart per Java](java-quickstart.md) per creare e distribuire un'applicazione web Java *Hello World* con l'EB CLI. Se sei interessato alle step-by-step istruzioni per creare una semplice applicazione *Hello World* Java JSP da distribuire con l'EB CLI sulla nostra piattaforma basata su Tomcat, prova il. [QuickStart per Java su Tomcat](tomcat-quickstart.md)

**La piattaforma Java si ramifica**  
AWS Elastic Beanstalk supporta due piattaforme per applicazioni Java.
+ **Tomcat**: una piattaforma basata su *Apache Tomcat*, un contenitore web open source per applicazioni che utilizzano servlet Java e JavaServer Pages (JSPs) per soddisfare le richieste HTTP. Tomcat facilita lo sviluppo di applicazioni Web offrendo multithreading, configurazione di sicurezza dichiarativa e uso esteso della personalizzazione. Elastic Beanstalk include rami di piattaforma per ciascuna delle attuali versioni principali di Tomcat. Per ulteriori informazioni, consulta [Piattaforma Tomcat](java-tomcat-platform.md).
+ **Java SE**: una piattaforma per applicazioni che non utilizzano un contenitore Web o ne utilizzano uno diverso da Tomcat, come Jetty o. GlassFish Puoi includere qualsiasi libreria Java Archives (JARs) utilizzata dall'applicazione nel pacchetto sorgente che distribuisci su Elastic Beanstalk. Per ulteriori informazioni, consulta [Piattaforma Java SE](java-se-platform.md).

Le filiali recenti delle piattaforme Tomcat e Java SE sono basate su Amazon Linux 2 e versioni successive e utilizzano *Corretto*, la distribuzione AWS Java SE. I nomi di questi rami della piattaforma includono la parola *Corretto* anziché *Java*.

Per un elenco delle versioni correnti della piattaforma, consulta [Tomcat](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.java) e [Java SE](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.javase) nella guida *Piattaforme AWS Elastic Beanstalk *.

**AWS strumenti**  
AWS fornisce diversi strumenti per lavorare con Java ed Elastic Beanstalk. Indipendentemente dal ramo della piattaforma scelto, puoi utilizzare l'[AWS SDK for Java per](java-development-environment.md#java-development-environment-sdk) utilizzare AWS altri servizi dall'interno della tua applicazione Java. L' AWS SDK for Java è un insieme di librerie che consentono di AWS APIs utilizzare il codice dell'applicazione senza scrivere da zero le chiamate HTTP non elaborate.

Se preferisci gestire le tue applicazioni dalla riga di comando, installa l'[Elastic Beanstalk Command Line](eb-cli3.md) Interface (EB CLI) e usala per creare, monitorare e gestire gli ambienti Elastic Beanstalk. Se si eseguono più ambienti per l'applicazione, la CLI EB si integra con Git per consentire di associare ciascuno di essi a un ramo Git diverso.

**Topics**
+ [

# QuickStart: distribuzione di un'applicazione Java su Elastic Beanstalk
](java-quickstart.md)
+ [

# QuickStart: Distribuisci un'applicazione web Java JSP per Tomcat su Elastic Beanstalk
](tomcat-quickstart.md)
+ [

# Configurazione dell'ambiente di sviluppo Java
](java-development-environment.md)
+ [

# Altri esempi di applicazioni e tutorial di Elastic Beanstalk per Java
](java-getstarted.md)
+ [

# Utilizzo della piattaforma Tomcat di Elastic Beanstalk
](java-tomcat-platform.md)
+ [

# Utilizzo della piattaforma Java SE di Elastic Beanstalk
](java-se-platform.md)
+ [

# Aggiungere un'istanza Amazon RDS DB all'ambiente Java Elastic Beanstalk
](java-rds.md)
+ [

# Strumenti e risorse Java
](create_deploy_Java.resources.md)

# QuickStart: distribuzione di un'applicazione Java su Elastic Beanstalk
<a name="java-quickstart"></a>

Questo QuickStart tutorial illustra il processo di creazione di un'applicazione Java e la sua distribuzione in un ambiente. AWS Elastic Beanstalk 

**Non per uso in produzione**  
Gli esempi sono solo a scopo dimostrativo. Non utilizzare applicazioni di esempio in produzione.

**Topics**
+ [

## Il tuo AWS account
](#java-quickstart-aws-account)
+ [

## Prerequisiti
](#java-quickstart-prereq)
+ [

## Passaggio 1: creare un'applicazione Java
](#java-quickstart-create-app)
+ [

## Passaggio 2: Esegui l'applicazione localmente
](#java-quickstart-run-local)
+ [

## Fase 3: Distribuire l'applicazione Java con l'EB CLI
](#java-quickstart-deploy)
+ [

## Fase 4: Esegui l'applicazione su Elastic Beanstalk
](#java-quickstart-run-eb-ap)
+ [

## Fase 5: rimozione
](#java-tutorial-cleanup)
+ [

## AWS risorse per la tua applicazione
](#java-quickstart-eb-resources)
+ [

## Fasi successive
](#java-quickstart-next-steps)
+ [

## Esegui la distribuzione con la console Elastic Beanstalk
](#java-quickstart-console)

## Il tuo AWS account
<a name="java-quickstart-aws-account"></a>

Se non sei già un AWS cliente, devi creare un AWS account. La registrazione ti consente di accedere a Elastic Beanstalk AWS e ad altri servizi di cui hai bisogno.

Se hai già un AWS account, puoi passare a. [Prerequisiti](#java-quickstart-prereq)

### Crea un AWS account
<a name="java-quickstart-aws-account-procedure"></a>

#### Registrati per un Account AWS
<a name="sign-up-for-aws"></a>

Se non ne hai uno Account AWS, completa i seguenti passaggi per crearne uno.

**Per iscriverti a un Account AWS**

1. Apri la [https://portal.aws.amazon.com/billing/registrazione.](https://portal.aws.amazon.com/billing/signup)

1. Segui le istruzioni online.

   Nel corso della procedura di registrazione riceverai una telefonata o un messaggio di testo e ti verrà chiesto di inserire un codice di verifica attraverso la tastiera del telefono.

   Quando ti iscrivi a un Account AWS, *Utente root dell'account AWS*viene creato un. L’utente root dispone dell’accesso a tutte le risorse e tutti i Servizi AWS nell’account. Come best practice di sicurezza, assegna l’accesso amministrativo a un utente e utilizza solo l’utente root per eseguire [attività che richiedono l’accesso di un utente root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS ti invia un'email di conferma dopo il completamento della procedura di registrazione. In qualsiasi momento, puoi visualizzare l'attività corrente del tuo account e gestirlo accedendo a [https://aws.amazon.com/](https://aws.amazon.com/)e scegliendo **Il mio account**.

#### Crea un utente con accesso amministrativo
<a name="create-an-admin"></a>

Dopo esserti registrato Account AWS, proteggi Utente root dell'account AWS AWS IAM Identity Center, abilita e crea un utente amministrativo in modo da non utilizzare l'utente root per le attività quotidiane.

**Proteggi i tuoi Utente root dell'account AWS**

1.  Accedi [Console di gestione AWS](https://console.aws.amazon.com/)come proprietario dell'account scegliendo **Utente root** e inserendo il tuo indirizzo Account AWS email. Nella pagina successiva, inserisci la password.

   Per informazioni sull’accesso utilizzando un utente root, consulta la pagina [Accedere come utente root](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) nella *Guida per l’utente di Accedi ad AWS *.

1. Abilita l’autenticazione a più fattori (MFA) per l’utente root.

   Per istruzioni, consulta [Abilitare un dispositivo MFA virtuale per l'utente Account AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) nella Guida per l'*utente IAM*.

**Crea un utente con accesso amministrativo**

1. Abilita il Centro identità IAM.

   Per istruzioni, consulta [Abilitazione del AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) nella *Guida per l’utente di AWS IAM Identity Center *.

1. Nel Centro identità IAM, assegna l’accesso amministrativo a un utente.

   Per un tutorial sull'utilizzo di IAM Identity Center directory come fonte di identità, consulta [Configurare l'accesso utente con l'impostazione predefinita IAM Identity Center directory](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) nella *Guida per l'AWS IAM Identity Center utente*.

**Accesso come utente amministratore**
+ Per accedere come utente del Centro identità IAM, utilizza l’URL di accesso che è stato inviato al tuo indirizzo e-mail quando hai creato l’utente del Centro identità IAM.

  Per informazioni sull'accesso utilizzando un utente IAM Identity Center, consulta [AWS Accedere al portale di accesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) nella *Guida per l'Accedi ad AWS utente*.

**Assegnazione dell’accesso ad altri utenti**

1. Nel Centro identità IAM, crea un set di autorizzazioni conforme alla best practice per l’applicazione di autorizzazioni con il privilegio minimo.

   Segui le istruzioni riportate nella pagina [Creazione di un set di autorizzazioni](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) nella *Guida per l’utente di AWS IAM Identity Center *.

1. Assegna al gruppo prima gli utenti e poi l’accesso con autenticazione unica (Single Sign-On).

   Per istruzioni, consulta [Aggiungere gruppi](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) nella *Guida per l’utente di AWS IAM Identity Center *.

## Prerequisiti
<a name="java-quickstart-prereq"></a>

Per seguire le procedure in questa guida, devi usare un terminale a riga di comando o una shell per eseguire i comandi. I comandi vengono visualizzati in elenchi preceduti da un simbolo di prompt (\$1) e dal nome della directory corrente, se appropriato.

```
~/eb-project$ this is a command
this is output
```

Su Linux e macOS usa la tua shell e il tuo programma di gestione dei pacchetti preferiti. Su Windows puoi [installare il sottosistema Windows per Linux per](https://docs.microsoft.com/en-us/windows/wsl/install-win10) ottenere una versione integrata per Windows di Ubuntu e Bash.

### CLI EB
<a name="java-quickstart-prereq.ebcli"></a>

Questo tutorial utilizza l'interfaccia a riga di comando di Elastic Beanstalk (CLI EB). Per istruzioni dettagliate su come configurare e utilizzare la CLI EB, consulta [Installa EB CLI con lo script di configurazione (consigliato)](eb-cli3.md#eb-cli3-install) e [Configurazione dell'interfaccia a riga di comando EB](eb-cli3-configuration.md).

### Java e Maven
<a name="java-quickstart-prereq.runtime"></a>

Se Amazon Corretto non è installato sul tuo computer locale, puoi installarlo seguendo [le istruzioni di installazione](https://docs.aws.amazon.com/corretto/latest/corretto-21-ug/amazon-linux-install.html) nella *Amazon Corretto User Guide*.

Verifica l'installazione di Java eseguendo il comando seguente.

```
~$ java -version 
```

Questo tutorial utilizza Maven. Segui le istruzioni per il [download](https://maven.apache.org/download.cgi) e [l'installazione](https://maven.apache.org/install.html) sul sito Web di Apache Maven Project. Per ulteriori informazioni su Maven, consulta il Maven [Users Center sul sito web del progetto Apache Maven](https://maven.apache.org/users/index.html).

Verifica l'installazione di Maven eseguendo il seguente comando.

```
~$ mvn -v
```

## Passaggio 1: creare un'applicazione Java
<a name="java-quickstart-create-app"></a>

Crea una directory di progetto.

```
~$ mkdir eb-java
~$ cd eb-java
```

Successivamente, crea un'applicazione che distribuirai utilizzando Elastic Beanstalk. Creeremo un servizio RESTful web «Hello World».

Questo esempio utilizza il framework [Spring Boot](https://spring.io/projects/spring-boot). Questa applicazione apre un listener sulla porta 5000. Elastic Beanstalk inoltra le richieste all'applicazione sulla porta 5000 per impostazione predefinita.

Crea i seguenti file:

Questo file crea una semplice applicazione Spring Boot.

**Example `~/eb-java/src/main/java/com/example/Application.java`**  

```
package com.example;

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

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
```

Questo file crea una mappatura che restituisce una stringa che definiamo qui.

**Example `~/eb-java/src/main/java/com/example/Controller.java`**  

```
package com.example;
    
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
    
@RestController
public class Controller {
    
    @GetMapping("/")
    public String index() {
       return "Hello Elastic Beanstalk!";
    }
}
```

Questo file definisce la configurazione del progetto Maven.

**Example `~/eb-java/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>3.2.3</version>
  </parent>

  <groupId>com.example</groupId>
  <artifactId>BeanstalkJavaExample</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <java.version>21</java.version>
  </properties>

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

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

</project>
```

Questo file di proprietà sostituisce la porta predefinita impostata su 5000. Questa è la porta predefinita a cui Elastic Beanstalk invia il traffico per le applicazioni Java.

**Example `~/eb-java/application.properties`**  

```
server.port=5000
```

## Passaggio 2: Esegui l'applicazione localmente
<a name="java-quickstart-run-local"></a>

Package della tua applicazione con il seguente comando:

```
~/eb-java$ mvn clean package
```

Esegui l'applicazione localmente con il seguente comando:

```
~/eb-java$ java -jar target/BeanstalkJavaExample-1.0-SNAPSHOT.jar
```

Mentre l'applicazione è in esecuzione, accedi al `http://127.0.0.1:5000/` menu nel tuo browser. Dovresti vedere il testo «Hello Elastic Beanstalk\$1».

## Fase 3: Distribuire l'applicazione Java con l'EB CLI
<a name="java-quickstart-deploy"></a>

Prima di distribuire l'applicazione Java su Elastic Beanstalk, puliamo l'applicazione di compilazione dalla directory e [creiamo](java-se-buildfile.md) un Buildfile e un Procfile per controllare come l'applicazione viene creata [ed](java-se-procfile.md) eseguita nell'ambiente Elastic Beanstalk.

**Per preparare e configurare la distribuzione delle applicazioni**

1. Pulisci l'applicazione integrata.

   ```
   ~/eb-java$ mvn clean
   ```

1. Crea un `Buildfile`.  
**Example `~/eb-java/Buildfile`**  

   ```
   build: mvn clean package
   ```

   Questo `Buildfile` specifica il comando usato per creare l'applicazione. Se non includi un file `Buildfile` per un'applicazione Java, Elastic Beanstalk non tenterà di creare la tua applicazione.

1. Crea un `Procfile`.  
**Example `~/eb-java/Procfile`**  

   ```
   web: java -jar target/BeanstalkJavaExample-1.0-SNAPSHOT.jar
   ```

   Questo `Procfile` specifica il comando usato per eseguire l'applicazione. Se non includi un file `Procfile` per un'applicazione Java, Elastic Beanstalk presuppone che ci sia un file JAR nella radice del pacchetto sorgente e tenta di eseguirlo con il comando. `java -jar`

 Ora che hai impostato i file di configurazione per creare e avviare l'applicazione, sei pronto per distribuirla. 

**Per creare un ambiente e distribuire l'applicazione Java**

1. Inizializza il repository della CLI EB con il comando **eb init**. 

   ```
   ~/eb-java eb init -p corretto java-tutorial --region us-east-2
           
   Application java-tutorial has been created.
   ```

   Questo comando crea un'applicazione denominata `java-tutorial` e configura il repository locale per creare ambienti con l'ultima versione della piattaforma Java.

1. (Facoltativo) Esegui nuovamente **eb init** per configurare una coppia di chiavi predefinite e connetterti all'istanza EC2 che esegue l'applicazione.

   ```
   ~/eb-java$ eb init
   Do you want to set up SSH for your instances?
   (y/n): y
   Select a keypair.
   1) my-keypair
   2) [ Create new KeyPair ]
   ```

   Seleziona una coppia di chiavi se ne hai già una, oppure segui le istruzioni per creare una nuova. Se il prompt non è visualizzato o devi modificare le impostazioni in seguito, esegui **eb init -i**.

1. Crea un ambiente e distribuisci in esso l'applicazione con **eb create**: Elastic Beanstalk crea automaticamente un file zip per l'applicazione e lo avvia sulla porta 5000.

   ```
   ~/eb-java$ eb create java-env
   ```

   Elastic Beanstalk impiega circa cinque minuti per creare l'ambiente.

## Fase 4: Esegui l'applicazione su Elastic Beanstalk
<a name="java-quickstart-run-eb-ap"></a>

Una volta completato il processo di creazione dell'ambiente, apri il sito Web con. **eb open**

```
~/eb-java eb open
```

Complimenti\$1 Hai distribuito un'applicazione Java con Elastic Beanstalk\$1 Si aprirà una finestra del browser che utilizza il nome di dominio creato per l'applicazione.

## Fase 5: rimozione
<a name="java-tutorial-cleanup"></a>

Puoi chiudere il tuo ambiente quando hai finito di lavorare con l'applicazione. Elastic Beanstalk AWS interrompe tutte le risorse associate all'ambiente.

Per terminare l'ambiente Elastic Beanstalk con l'EB CLI, esegui il comando seguente.

```
~/eb-java$ eb terminate
```

## AWS risorse per la tua applicazione
<a name="java-quickstart-eb-resources"></a>

Hai appena creato un'applicazione a istanza singola. Funge da semplice applicazione di esempio con una singola istanza EC2, quindi non richiede il bilanciamento del carico o la scalabilità automatica. Per le applicazioni a istanza singola Elastic Beanstalk crea le seguenti risorse: AWS 
+ **Istanza EC2**: una macchina virtuale di Amazon EC2 configurata per eseguire applicazioni Web sulla piattaforma selezionata.

  Ogni piattaforma esegue un insieme diverso di software, file di configurazione e script per supportare una versione della lingua, un framework, un container Web specifici o una determinata combinazione di tutti questi elementi. La maggior parte delle piattaforme utilizza Apache o nginx come proxy inverso che elabora il traffico web su cui viene eseguita l'app Web, inoltra le richieste all'app, fornisce asset statici e genera log degli accessi e di errore.
+ **Gruppo di sicurezza istanze**: un gruppo di sicurezza di Amazon EC2 configurato per abilitare il traffico in entrata sulla porta 80. Questa risorsa consente al traffico TTP proveniente dal load balancer di raggiungere l'istanza EC2 in esecuzione sull'app Web. Per impostazione predefinita, il traffico non è consentito su altre porte.
+ **Bucket Amazon S3**: posizione di storage per il codice sorgente, i log e altri artefatti creati quando si utilizza Elastic Beanstalk.
+ ** CloudWatch Allarmi Amazon**: due CloudWatch allarmi che monitorano il carico sulle istanze nel tuo ambiente e vengono attivati se il carico è troppo alto o troppo basso. Quando viene attivato un allarme, il gruppo Auto Scaling aumenta o diminuisce di conseguenza.
+ **CloudFormation stack**: Elastic CloudFormation Beanstalk utilizza per avviare le risorse nell'ambiente e propagare le modifiche alla configurazione. Le risorse sono definite in un modello, visualizzabile nella [console CloudFormation](https://console.aws.amazon.com/cloudformation).
+  **Nome di dominio***: un nome di dominio che indirizza alla tua app Web nel modulo. *subdomain* *region*.elasticbeanstalk.com*. 

Elastic Beanstalk gestisce tutte queste risorse. Quando arresti l'ambiente, Elastic Beanstalk termina tutte le risorse che contiene.

## Fasi successive
<a name="java-quickstart-next-steps"></a>

Quando disponi di un'applicazione in esecuzione in un ambiente, puoi distribuire una nuova versione dell'applicazione o un'applicazione diversa in qualsiasi momento. La distribuzione di una nuova versione dell'applicazione è molto veloce perché non richiede il provisioning o il riavvio delle istanze EC2. Puoi anche esplorare il tuo nuovo ambiente utilizzando la console Elastic Beanstalk. Per i passaggi dettagliati, consulta [Esplora il tuo ambiente](GettingStarted.md#GettingStarted.Explore) nel capitolo *Guida introduttiva* di questa guida.

**Prova altri tutorial**  
Se desideri provare altri tutorial con diverse applicazioni di esempio, consulta. [Esempi di applicazioni e tutorial](java-getstarted.md)

Dopo aver distribuito una o due applicazioni di esempio e essere pronti per iniziare a sviluppare ed eseguire applicazioni Java localmente, consulta. [Configurazione dell'ambiente di sviluppo Java](java-development-environment.md) 

## Esegui la distribuzione con la console Elastic Beanstalk
<a name="java-quickstart-console"></a>

Puoi anche utilizzare la console Elastic Beanstalk per avviare l'applicazione di esempio. Per i passaggi dettagliati, consulta [Creare un'applicazione di esempio](GettingStarted.md#GettingStarted.CreateApp) nel capitolo *Guida introduttiva* di questa guida.

# QuickStart: Distribuisci un'applicazione web Java JSP per Tomcat su Elastic Beanstalk
<a name="tomcat-quickstart"></a>

Questo tutorial illustra il processo di creazione di una semplice applicazione web Java utilizzando Pages (). JavaServer JSPs Se desideri raggruppare più applicazioni Web sotto forma di file WAR in un unico ambiente Elastic Beanstalk, consulta. [Raggruppamento di più file WAR per ambienti Tomcat](java-tomcat-multiple-war-files.md)

**Non per uso in produzione**  
Gli esempi sono solo a scopo dimostrativo. Non utilizzare applicazioni di esempio in produzione.

**Topics**
+ [

## Il tuo AWS account
](#tomcat-quickstart-aws-account)
+ [

## Prerequisiti
](#tomcat-quickstart-prereq)
+ [

## Fase 1: Creare un'applicazione Java JSP
](#tomcat-quickstart-create-app)
+ [

## Fase 2: Distribuire l'applicazione Java JSP con l'EB CLI
](#tomcat-quickstart-deploy)
+ [

## Fase 3: Esegui l'applicazione su Elastic Beanstalk
](#tomcat-quickstart-run-eb-ap)
+ [

## Fase 4: pulizia
](#go-tutorial-cleanup)
+ [

## AWS risorse per la tua applicazione
](#tomcat-quickstart-eb-resources)
+ [

## Fasi successive
](#tomcat-quickstart-next-steps)
+ [

## Esegui la distribuzione con la console Elastic Beanstalk
](#tomcat-quickstart-console)

## Il tuo AWS account
<a name="tomcat-quickstart-aws-account"></a>

Se non sei già un AWS cliente, devi creare un AWS account. La registrazione ti consente di accedere a Elastic Beanstalk AWS e ad altri servizi di cui hai bisogno.

Se hai già un AWS account, puoi passare a. [Prerequisiti](#tomcat-quickstart-prereq)

### Crea un AWS account
<a name="tomcat-quickstart-aws-account-procedure"></a>

#### Registrati per un Account AWS
<a name="sign-up-for-aws"></a>

Se non ne hai uno Account AWS, completa i seguenti passaggi per crearne uno.

**Per iscriverti a un Account AWS**

1. Apri la [https://portal.aws.amazon.com/billing/registrazione.](https://portal.aws.amazon.com/billing/signup)

1. Segui le istruzioni online.

   Nel corso della procedura di registrazione riceverai una telefonata o un messaggio di testo e ti verrà chiesto di inserire un codice di verifica attraverso la tastiera del telefono.

   Quando ti iscrivi a un Account AWS, *Utente root dell'account AWS*viene creato un. L’utente root dispone dell’accesso a tutte le risorse e tutti i Servizi AWS nell’account. Come best practice di sicurezza, assegna l’accesso amministrativo a un utente e utilizza solo l’utente root per eseguire [attività che richiedono l’accesso di un utente root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS ti invia un'email di conferma dopo il completamento della procedura di registrazione. In qualsiasi momento, puoi visualizzare l'attività corrente del tuo account e gestirlo accedendo a [https://aws.amazon.com/](https://aws.amazon.com/)e scegliendo **Il mio account**.

#### Crea un utente con accesso amministrativo
<a name="create-an-admin"></a>

Dopo esserti registrato Account AWS, proteggi Utente root dell'account AWS AWS IAM Identity Center, abilita e crea un utente amministrativo in modo da non utilizzare l'utente root per le attività quotidiane.

**Proteggi i tuoi Utente root dell'account AWS**

1.  Accedi [Console di gestione AWS](https://console.aws.amazon.com/)come proprietario dell'account scegliendo **Utente root** e inserendo il tuo indirizzo Account AWS email. Nella pagina successiva, inserisci la password.

   Per informazioni sull’accesso utilizzando un utente root, consulta la pagina [Accedere come utente root](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) nella *Guida per l’utente di Accedi ad AWS *.

1. Abilita l’autenticazione a più fattori (MFA) per l’utente root.

   Per istruzioni, consulta [Abilitare un dispositivo MFA virtuale per l'utente Account AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) nella Guida per l'*utente IAM*.

**Crea un utente con accesso amministrativo**

1. Abilita il Centro identità IAM.

   Per istruzioni, consulta [Abilitazione del AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) nella *Guida per l’utente di AWS IAM Identity Center *.

1. Nel Centro identità IAM, assegna l’accesso amministrativo a un utente.

   Per un tutorial sull'utilizzo di IAM Identity Center directory come fonte di identità, consulta [Configurare l'accesso utente con l'impostazione predefinita IAM Identity Center directory](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) nella *Guida per l'AWS IAM Identity Center utente*.

**Accesso come utente amministratore**
+ Per accedere come utente del Centro identità IAM, utilizza l’URL di accesso che è stato inviato al tuo indirizzo e-mail quando hai creato l’utente del Centro identità IAM.

  Per informazioni sull'accesso utilizzando un utente IAM Identity Center, consulta [AWS Accedere al portale di accesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) nella *Guida per l'Accedi ad AWS utente*.

**Assegnazione dell’accesso ad altri utenti**

1. Nel Centro identità IAM, crea un set di autorizzazioni conforme alla best practice per l’applicazione di autorizzazioni con il privilegio minimo.

   Segui le istruzioni riportate nella pagina [Creazione di un set di autorizzazioni](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) nella *Guida per l’utente di AWS IAM Identity Center *.

1. Assegna al gruppo prima gli utenti e poi l’accesso con autenticazione unica (Single Sign-On).

   Per istruzioni, consulta [Aggiungere gruppi](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) nella *Guida per l’utente di AWS IAM Identity Center *.

## Prerequisiti
<a name="tomcat-quickstart-prereq"></a>

Per seguire le procedure in questa guida, devi usare un terminale a riga di comando o una shell per eseguire i comandi. I comandi vengono visualizzati in elenchi preceduti da un simbolo di prompt (\$1) e dal nome della directory corrente, se appropriato.

```
~/eb-project$ this is a command
this is output
```

Su Linux e macOS usa la tua shell e il tuo programma di gestione dei pacchetti preferiti. Su Windows puoi [installare il sottosistema Windows per Linux per](https://docs.microsoft.com/en-us/windows/wsl/install-win10) ottenere una versione integrata per Windows di Ubuntu e Bash.

### CLI EB
<a name="tomcat-quickstart-prereq.ebcli"></a>

Questo tutorial utilizza l'interfaccia a riga di comando di Elastic Beanstalk (CLI EB). Per istruzioni dettagliate su come configurare e utilizzare la CLI EB, consulta [Installa EB CLI con lo script di configurazione (consigliato)](eb-cli3.md#eb-cli3-install) e [Configurazione dell'interfaccia a riga di comando EB](eb-cli3-configuration.md).

## Fase 1: Creare un'applicazione Java JSP
<a name="tomcat-quickstart-create-app"></a>

Crea una directory di progetto.

```
~$ mkdir eb-tomcat
~$ cd eb-tomcat
```

Successivamente, crea un'applicazione che distribuirai utilizzando Elastic Beanstalk. Creeremo un'applicazione web «Hello World».

Crea un semplice file JSP denominato`index.jsp`.

**Example `~/eb-tomcat/index.jsp`**  

```
<html>
  <body>
    <%out.println("Hello Elastic Beanstalk!");%>
  </body>
</html>
```

## Fase 2: Distribuire l'applicazione Java JSP con l'EB CLI
<a name="tomcat-quickstart-deploy"></a>

Esegui i seguenti comandi per creare un ambiente Elastic Beanstalk per questa applicazione.

 

**Per creare un ambiente e distribuire l'applicazione Java JSP**

1. Inizializza il repository della CLI EB con il comando **eb init**.

   ```
   ~/eb-tomcat$ eb init -p tomcat tomcat-tutorial --region us-east-2
   ```

   Questo comando crea un'applicazione denominata `tomcat-tutorial` e configura il repository locale per creare ambienti con l'ultima versione della piattaforma Tomcat.

1. (Facoltativo) Esegui nuovamente **eb init** per configurare una coppia di chiavi predefinite e connetterti all'istanza EC2 che esegue l'applicazione.

   ```
   ~/eb-go$ eb init
   Do you want to set up SSH for your instances?
   (y/n): y
   Select a keypair.
   1) my-keypair
   2) [ Create new KeyPair ]
   ```

   Seleziona una coppia di chiavi se ne hai già una, oppure segui le istruzioni per creare una nuova. Se il prompt non è visualizzato o devi modificare le impostazioni in seguito, esegui **eb init -i**.

1. Crea un ambiente e distribuisci in esso l'applicazione con **eb create**: Elastic Beanstalk crea automaticamente un file zip per l'applicazione e lo avvia sulla porta 5000.

   ```
   ~/eb-tomcat$ eb create tomcat-env
   ```

   Elastic Beanstalk impiega circa cinque minuti per creare l'ambiente.

## Fase 3: Esegui l'applicazione su Elastic Beanstalk
<a name="tomcat-quickstart-run-eb-ap"></a>

Una volta completato il processo di creazione dell'ambiente, apri il sito Web con. **eb open**

```
~/eb-tomcat$ eb open
```

Complimenti\$1 Hai distribuito un'applicazione Java JSP con Elastic Beanstalk\$1 Si aprirà una finestra del browser che utilizza il nome di dominio creato per l'applicazione.

## Fase 4: pulizia
<a name="go-tutorial-cleanup"></a>

Puoi chiudere il tuo ambiente quando finisci di lavorare con l'applicazione. Elastic Beanstalk AWS interrompe tutte le risorse associate all'ambiente.

Per terminare l'ambiente Elastic Beanstalk con l'EB CLI, esegui il comando seguente.

```
~/eb-tomcat$ eb terminate
```

## AWS risorse per la tua applicazione
<a name="tomcat-quickstart-eb-resources"></a>

Hai appena creato un'applicazione a istanza singola. Funge da semplice applicazione di esempio con una singola istanza EC2, quindi non richiede il bilanciamento del carico o la scalabilità automatica. Per le applicazioni a istanza singola Elastic Beanstalk crea le seguenti risorse: AWS 
+ **Istanza EC2**: una macchina virtuale di Amazon EC2 configurata per eseguire applicazioni Web sulla piattaforma selezionata.

  Ogni piattaforma esegue un insieme diverso di software, file di configurazione e script per supportare una versione della lingua, un framework, un container Web specifici o una determinata combinazione di tutti questi elementi. La maggior parte delle piattaforme utilizza Apache o nginx come proxy inverso che elabora il traffico web su cui viene eseguita l'app Web, inoltra le richieste all'app, fornisce asset statici e genera log degli accessi e di errore.
+ **Gruppo di sicurezza istanze**: un gruppo di sicurezza di Amazon EC2 configurato per abilitare il traffico in entrata sulla porta 80. Questa risorsa consente al traffico TTP proveniente dal load balancer di raggiungere l'istanza EC2 in esecuzione sull'app Web. Per impostazione predefinita, il traffico non è consentito su altre porte.
+ **Bucket Amazon S3**: posizione di storage per il codice sorgente, i log e altri artefatti creati quando si utilizza Elastic Beanstalk.
+ ** CloudWatch Allarmi Amazon**: due CloudWatch allarmi che monitorano il carico sulle istanze nel tuo ambiente e vengono attivati se il carico è troppo alto o troppo basso. Quando viene attivato un allarme, il gruppo Auto Scaling aumenta o diminuisce di conseguenza.
+ **CloudFormation stack**: Elastic CloudFormation Beanstalk utilizza per avviare le risorse nell'ambiente e propagare le modifiche alla configurazione. Le risorse sono definite in un modello, visualizzabile nella [console CloudFormation](https://console.aws.amazon.com/cloudformation).
+  **Nome di dominio***: un nome di dominio che indirizza alla tua app Web nel modulo. *subdomain* *region*.elasticbeanstalk.com*. 

Elastic Beanstalk gestisce tutte queste risorse. Quando arresti l'ambiente, Elastic Beanstalk termina tutte le risorse che contiene.

## Fasi successive
<a name="tomcat-quickstart-next-steps"></a>

Quando disponi di un'applicazione in esecuzione in un ambiente, puoi distribuire una nuova versione dell'applicazione o un'applicazione diversa in qualsiasi momento. La distribuzione di una nuova versione dell'applicazione è molto veloce perché non richiede il provisioning o il riavvio delle istanze EC2. Puoi anche esplorare il tuo nuovo ambiente utilizzando la console Elastic Beanstalk. Per i passaggi dettagliati, consulta [Esplora il tuo ambiente](GettingStarted.md#GettingStarted.Explore) nel capitolo *Guida introduttiva* di questa guida.

**Prova altri tutorial**  
Se desideri provare altri tutorial con diverse applicazioni di esempio, consulta. [Esempi di applicazioni e tutorial](java-getstarted.md)

Dopo aver distribuito una o due applicazioni di esempio e essere pronti per iniziare a sviluppare ed eseguire applicazioni Java in un contenitore web Tomcat locale, vedi. [Configurazione dell'ambiente di sviluppo Java](java-development-environment.md) 

## Esegui la distribuzione con la console Elastic Beanstalk
<a name="tomcat-quickstart-console"></a>

Puoi anche utilizzare la console Elastic Beanstalk per avviare l'applicazione di esempio. Per i passaggi dettagliati, consulta [Creare un'applicazione di esempio](GettingStarted.md#GettingStarted.CreateApp) nel capitolo *Guida introduttiva* di questa guida.

# Configurazione dell'ambiente di sviluppo Java
<a name="java-development-environment"></a>

Questo argomento fornisce istruzioni per configurare un ambiente di sviluppo Java per testare l'applicazione localmente prima di distribuirla AWS Elastic Beanstalk. Fa inoltre riferimento a siti Web che forniscono istruzioni di installazione per strumenti utili.

**Topics**
+ [

## Installazione di Java Development Kit
](#java-development-environment-jdk)
+ [

## Installazione di un container Web
](#java-development-environment-tomcat)
+ [

## Download di librerie
](#java-development-environment-libraries)
+ [

## Installazione dell' AWS SDK for Java
](#java-development-environment-sdk)
+ [

## Installazione di un IDE o un editor di testo
](#java-development-environment-ide)

## Installazione di Java Development Kit
<a name="java-development-environment-jdk"></a>

Installa Java Development Kit (JDK). Se non hai preferenze, scarica la versione più recente Scarica il JDK dal sito [oracle.com](http://www.oracle.com/technetwork/java/javase/downloads/index.html). 

JDK include il compilatore Java, con cui è possibile creare file di origine in file di classe eseguibili su un server Web Elastic Beanstalk.

## Installazione di un container Web
<a name="java-development-environment-tomcat"></a>

Se non disponi già di un altro contenitore o framework Web, installa una versione di Tomcat supportata da Elastic Beanstalk per il tuo sistema operativo Amazon Linux. [https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.java](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.java) [Scarica la versione di Tomcat adatta al tuo ambiente dal sito Web di Apache Tomcat.](http://tomcat.apache.org) 

## Download di librerie
<a name="java-development-environment-libraries"></a>

Le piattaforme Elastic Beanstalk includono alcune librerie per impostazione predefinita. Scarica le librerie che l'applicazione utilizzerà e salvale nella tua cartella di progetto per una distribuzione nel bundle di origine dell'applicazione.

Se hai installato Tomcat localmente, puoi copiare le librerie API servlet e JavaServer Pages (JSP) dalla cartella di installazione. Se esegui la distribuzione in una versione della piattaforma Tomcat, questi file non devono essere nel bundle di origine, ma in `classpath` allo scopo di compilare qualsiasi classe che li utilizza.

JUnit, Google Guava e Apache Commons forniscono diverse librerie utili. Visita le relative home page per ulteriori informazioni:
+  [Scarica JUnit](https://github.com/junit-team/junit/wiki/Download-and-Install) 
+  [Scarica Google Guava](https://code.google.com/p/guava-libraries/) 
+  [Scarica Apache Commons](http://commons.apache.org/downloads/) 

## Installazione dell' AWS SDK for Java
<a name="java-development-environment-sdk"></a>

Se devi gestire AWS le risorse dall'interno dell'applicazione, installa l' AWS SDK for Java. Ad esempio, con AWS SDK per Java, è possibile utilizzare Amazon DynamoDB (DynamoDB) per condividere gli stati di sessione delle applicazioni Apache Tomcat su più server Web. Per ulteriori informazioni, consulta [Gestire lo stato della sessione Tomcat con Amazon](https://docs.aws.amazon.com/AWSSdkDocsJava/latest/DeveloperGuide/java-dg-tomcat-session-manager.html) DynamoDB nella documentazione AWS SDK for Java.

Visita la [home page dell'SDK AWS per Java](https://aws.amazon.com/sdk-for-java/) per ulteriori informazioni e istruzioni di installazione.

## Installazione di un IDE o un editor di testo
<a name="java-development-environment-ide"></a>

Gli ambienti di sviluppo integrati (IDEs) offrono un'ampia gamma di funzionalità che facilitano lo sviluppo di applicazioni. Se non hai utilizzato un IDE per lo sviluppo Java, prova Eclipse e IntelliJ e determina qual è il più appropriato.
+  [Installazione dell'IDE di Eclipse per sviluppatori Java EE](https://www.eclipse.org/downloads/) 
+  [Installazione di IntelliJ](https://www.jetbrains.com/idea/) 

Un IDE potrebbe aggiungere file alla tua cartella di progetto di cui non intendi eseguire il commit nel controllo del codice sorgente. Per impedire il commit di questi file nel controllo del codice sorgente, utilizza `.gitignore` o uno strumento di controllo del codice sorgente equivalente.

Se vuoi solo iniziare a scrivere codice e non hai bisogno di tutte le caratteristiche di un IDE, prendi in considerazione l'[installazione di Sublime Text](http://www.sublimetext.com/).

**Nota**  
Il 31 maggio 2023, [AWS Toolkit for Eclipse](https://docs.aws.amazon.com//toolkit-for-eclipse/v1/user-guide/welcome.html)ha raggiunto la fine del ciclo di vita e non è più supportato da AWS. Per ulteriori dettagli sulla fine del ciclo di vita di AWS Toolkit for Eclipse, consultate il file [README.md](https://github.com/aws/aws-toolkit-eclipse) nel repository. AWS Toolkit for Eclipse GitHub 

# Altri esempi di applicazioni e tutorial di Elastic Beanstalk per Java
<a name="java-getstarted"></a>

Questa sezione fornisce applicazioni e tutorial aggiuntivi. [QuickStart per Java su Tomcat](tomcat-quickstart.md)Gli argomenti [QuickStart per Java](java-quickstart.md) descritti in precedenza in questo argomento illustrano l'avvio di un'applicazione Java di esempio con l'EB CLI.

Per iniziare a utilizzare le applicazioni Java AWS Elastic Beanstalk, è sufficiente un [pacchetto di sorgenti](applications-sourcebundle.md) di applicazioni da caricare come prima versione dell'applicazione e da distribuire in un ambiente. Quando crei un ambiente, Elastic Beanstalk alloca tutte le risorse AWS necessarie per eseguire un'applicazione Web scalabile.

## Avvio di un ambiente con un'applicazione Java di esempio
<a name="java-getstarted-samples"></a>

Elastic Beanstalk fornisce applicazioni di esempio a pagina singola per ogni piattaforma, nonché esempi più complessi che mostrano l'uso di risorse AWS aggiuntive come Amazon RDS e funzionalità specifiche del linguaggio o della piattaforma e. APIs

Gli esempi di singole pagine hanno lo stesso codice che ottieni al momento della creazione di un ambiente senza fornire il tuo codice sorgente. Gli esempi più complessi sono ospitati su GitHub e potrebbe essere necessario compilarli o crearli prima della distribuzione in un ambiente Elastic Beanstalk.

 


**Esempi**  

|  Name  |  Versioni supportate  |  Tipo di ambiente  |  Origine  |  Descrizione  | 
| --- | --- | --- | --- | --- | 
|  Tomcat (pagina singola)  |  Tutti i rami della piattaforma *Tomcat con Corretto*  |  Server Web Worker  |   [tomcat.zip](samples/tomcat.zip)   |  Applicazione Web Tomcat con un'unica pagina (`index.jsp`) configurata per essere visualizzata nel sito Web radice. Per gli [ambienti lavoratore](using-features-managing-env-tiers.md), questo esempio include un file `cron.yaml` che configura un'attività pianificata per chiamare `scheduled.jsp` una volta al minuto. Quando viene chiamato `scheduled.jsp`, viene eseguita la scrittura in un file di log in `/tmp/sample-app.log`. Infine, un file di configurazione viene incluso in `.ebextensions` che copia i log da `/tmp/` per le posizioni lette da Elastic Beanstalk al momento della richiesta dei log di ambiente. Se [abiliti l'integrazione X-Ray](environment-configuration-debugging.md) in un ambiente con questo esempio in esecuzione, l'applicazione mostra contenuti aggiuntivi riguardanti X-Ray e offre un'opzione per generare informazioni di debug che puoi visualizzare nella console X-Ray.  | 
|  Corretto (pagina singola)  |  Corretto 11 Corretto 8  |  Server Web  |  [corretto.zip](samples/corretto.zip)  |  Applicazione Corretto con i file di configurazione `Buildfile` e `Procfile`. Se [abiliti l'integrazione X-Ray](environment-configuration-debugging.md) in un ambiente con questo esempio in esecuzione, l'applicazione mostra contenuti aggiuntivi riguardanti X-Ray e offre un'opzione per generare informazioni di debug che puoi visualizzare nella console X-Ray.  | 
|  Scorekeep  | Java 8 | Server Web | [Clona il repository su .com GitHub](https://github.com/awslabs/eb-java-scorekeep) |  *Scorekeep* è un'API RESTful web che utilizza il framework Spring per fornire un'interfaccia per la creazione e la gestione di utenti, sessioni e giochi. L'API è integrata con un'app Web Angular 1.5 che consuma l'API sull'HTTP. L'applicazione utilizza caratteristiche della piattaforma Java SE per scaricare dipendenze e creare on-instance, riducendo al minimo le dimensioni del bundle di origine. L'applicazione include anche file di configurazione nginx che sovrascrivono la configurazione predefinita per servire l'app Web di front-end in modo statico sulla porta 80 tramite il proxy, e instradare le richieste su percorsi in `/api` all'API in esecuzione su `localhost:5000`. Scorekeep include anche un ramo `xray` che mostra come approntare un'applicazione Java per l'uso con AWS X-Ray. Mostra la strumentazione delle richieste HTTP in entrata con un filtro servlet, la strumentazione client AWS SDK automatica e manuale, la configurazione del registratore e la strumentazione delle richieste HTTP in uscita e dei client SQL. Consulta il file Readme per istruzioni oppure utilizza il [Tutorial sulle nozioni di base di AWS X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/xray-gettingstarted.html) per provare l'applicazione con X-Ray.  | 
|  Does it Have Snakes?  | Tomcat 8 con Java 8 | Server Web | [Clona il repository su .com GitHub](https://github.com/awslabs/eb-tomcat-snakes) |  *Ha serpenti?* è un'applicazione web Tomcat che mostra l'uso dei file di configurazione Elastic Beanstalk, Amazon RDS, JDBC, PostgreSQL, JSPs Servlets, Simple Tag Support, Tag Files, Log4J, Bootstrap e Jackson. Il codice sorgente per questo progetto include uno script di build minimo che compila i servlet e i modelli in file delle classi e crea un pacchetto dei file richiesti in un archivio Web che puoi distribuire in un ambiente Elastic Beanstalk. Vedi il file Readme nell'archivio del progetto per le istruzioni complete.  | 
| Locust Load Generator | Java 8 | Server Web | [ GitHubClona il repository su .com](https://github.com/awslabs/eb-locustio-sample) |  Applicazione Web che puoi utilizzare per eseguire il test di carico di un'altra applicazione Web in esecuzione in un ambiente Elastic Beanstalk diverso. Mostra l'uso dei file `Buildfile` e `Procfile`, DynamoDB e [Locust](http://locust.io/), uno strumento di test del carico open source.  | 

Scarica una delle applicazioni di esempio e distribuiscila su Elastic Beanstalk seguendo questi passaggi:

**Per avviare un ambiente con un'applicazione (console)**

1. Apri la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) e, **nell'elenco Regioni, seleziona la tua**. Regione AWS

1. Nel riquadro di navigazione, scegliere **Applications (Applicazioni)**. Seleziona un'applicazione esistente nell'elenco. Puoi anche scegliere di crearne una seguendo le istruzioni riportate in[Gestione delle applicazioni ](applications.md).

1. Nella pagina di panoramica dell'applicazione, scegli **Crea ambiente**.

   Verrà avviata la procedura guidata **Create environment** (Creazione dell'ambiente). La procedura guidata fornisce una procedura che consente di creare un nuovo ambiente.

1. Per il **livello Ambiente**, scegli il [livello **Ambiente server Web****o Ambiente**](concepts.md#concepts-tier) di lavoro. Non è possibile modificare un piano di un ambiente dopo la creazione.
**Nota**  
La [piattaforma .NET su Windows Server](create_deploy_NET.md) non supporta il piano di ambiente operatore.

   I campi di **informazioni sull'applicazione** sono predefiniti, in base all'applicazione scelta in precedenza.

   Nel gruppo di **informazioni sull'ambiente**, il valore predefinito del **nome dell'ambiente** è basato sul nome dell'applicazione. Se preferisci un nome di ambiente diverso, puoi inserire un altro valore nel campo. Facoltativamente, puoi inserire un nome di **dominio**; in caso contrario Elastic Beanstalk genera automaticamente un valore. **Facoltativamente, puoi anche inserire una descrizione dell'ambiente.**

1. Per **Piattaforma**, selezionare il ramo della piattaforma e la piattaforma che corrispondono al linguaggio utilizzato dall'applicazione.
**Nota**  
Elastic Beanstalk supporta più [versioni](concepts.platforms.md) per la maggior parte delle piattaforme elencate. Per impostazione predefinita, la console seleziona la versione consigliata per il ramo della piattaforma e per la piattaforma di scelta. Se l'applicazione richiede una versione diversa, puoi selezionarla qui. Per informazioni sulle versioni della piattaforma supportate, consulta [Piattaforme supportate da Elastic Beanstalk](concepts.platforms.md).

1. Per il **codice dell'applicazione**, sono disponibili diverse scelte per procedere.
   + Per avviare l'applicazione di esempio predefinita senza fornire il codice sorgente, scegliete **Applicazione di esempio**. Questa azione sceglie l'applicazione a pagina singola fornita da Elastic Beanstalk per la piattaforma selezionata in precedenza.
   + Se hai scaricato un'applicazione di esempio da questa guida o disponi del tuo codice sorgente per un'applicazione, procedi nel seguente modo.

     1. Seleziona **Carica il tuo codice**.

     1. Quindi scegli **File locale**, quindi in **Carica applicazione**, seleziona **Scegli file**.

     1. Il sistema operativo del computer client ti presenterà un'interfaccia per selezionare il file locale che hai scaricato. Seleziona il file del pacchetto sorgente e continua.

1. La scelta delle **impostazioni predefinite** dipende dallo scopo dell'ambiente.
   + Se stai creando un ambiente di esempio per conoscere Elastic Beanstalk o un ambiente di sviluppo**, scegli Istanza singola** (idoneo al piano gratuito).
   + **Se stai creando un ambiente di produzione o un ambiente per saperne di più sul bilanciamento del carico, scegli una delle opzioni di alta disponibilità.**

1. Scegli **Next (Successivo)**.

**Per configurare l'accesso al servizio**  
Successivamente, sono necessari due ruoli. Un *ruolo di servizio* consente a Elastic Beanstalk di monitorare le istanze EC2 e aggiornare la piattaforma dell'ambiente. Un ruolo di *profilo di istanza EC2* consente attività come la scrittura di log e l'interazione con altri servizi.

**Per creare o selezionare il ruolo Service**

1. Se hai già creato un **ruolo di servizio** e desideri sceglierne uno esistente, seleziona il valore dal menu a discesa **Ruolo di servizio e salta il resto di questi passaggi per creare un ruolo** di servizio.

1. Se non vedi alcun valore elencato per il **ruolo di servizio** o desideri crearne uno nuovo, continua con i passaggi successivi.

1. Per **Ruolo di servizio**, scegli **Crea ruolo**.

1. Per **Tipo di entità attendibile**, scegli **Servizio AWS **.

1. Per il **caso d'uso**, scegli **Elastic Beanstalk — Environment**.

1. Scegli **Next (Successivo)**.

1. **Verifica che i **criteri di autorizzazione** includano quanto segue, quindi scegli Avanti:**
   + `AWSElasticBeanstalkEnhancedHealth`
   + `AWSElasticBeanstalkManagedUpdatesCustomerRolePolicy`

1. Scegli **Crea ruolo**.

1. Torna alla scheda **Configura l'accesso al servizio**, aggiorna l'elenco, quindi seleziona il ruolo di servizio appena creato.

**Per creare o selezionare un profilo di istanza EC2**

1. Se hai già creato un **profilo di istanza EC2** e desideri sceglierne uno esistente, seleziona il valore dal menu a discesa del **profilo dell'istanza EC2** e salta il resto di questi passaggi per creare un profilo di istanza EC2.

1. Se non vedi alcun valore elencato per il **profilo dell'istanza EC2** o desideri crearne uno nuovo, continua con i passaggi successivi.

1. Scegli **Crea ruolo**.

1. Per **Tipo di entità attendibile**, scegli **Servizio AWS **.

1. Per il **caso d'uso**, scegli **Elastic Beanstalk — Compute**.

1. Scegli **Next (Successivo)**.

1. **Verifica che i **criteri di autorizzazione** includano quanto segue, quindi scegli Avanti:**
   + `AWSElasticBeanstalkWebTier`
   + `AWSElasticBeanstalkWorkerTier`
   + `AWSElasticBeanstalkMulticontainerDocker`

1. Scegli **Crea ruolo**.

1. Torna alla scheda **Configura l'accesso al servizio**, aggiorna l'elenco, quindi seleziona il profilo di istanza EC2 appena creato.

**Per completare la configurazione e la creazione dell'applicazione**

1. (Facoltativo) Se in precedenza hai creato una coppia di chiavi EC2, puoi selezionarla dal menu a discesa del campo delle **coppie di chiavi EC2**. Puoi utilizzarlo per accedere in modo sicuro all'istanza Amazon EC2 fornita da Elastic Beanstalk per la tua applicazione. Se salti questo passaggio, puoi sempre creare e assegnare una coppia di key pair EC2 dopo la creazione dell'ambiente. Per ulteriori informazioni, consulta [EC2 key pair](using-features.managing.security.md#using-features.managing.security.keypair).

1. Scegli **Skip to Review** (Passa alla revisione) nella pagina **Configure service access** (Configura l'accesso al servizio).

1. La pagina **Review** (Revisione) mostra un riepilogo di tutte le tue scelte.

   Per personalizzare ulteriormente l'ambiente, scegli **Edit** (Modifica) accanto al passaggio che include tutti gli elementi che desideri configurare. Le seguenti opzioni possono essere impostate solo durante la creazione dell'ambiente:
   + Nome ambiente
   + Nome dominio
   + Versione della piattaforma
   + Processore
   + Nuovo tipo di load balancer
   + Livello

   Le seguenti impostazioni possono essere modificate dopo la creazione dell'ambiente, ma richiedono nuove istanze o altre risorse per il provisioning e i tempi di applicazione possono essere lunghi:
   + Tipo di istanza, volume root, key pair e ruolo AWS Identity and Access Management (IAM)
   + Database interno Amazon RDS
   + VPC

   Per ulteriori dettagli sulle impostazioni disponibili, consulta [Procedura guidata per la creazione del nuovo ambiente](environments-create-wizard.md).

1. Scegli **Submit** (Invia) nella parte inferiore della pagina per inizializzare la creazione del nuovo ambiente.

## Fasi successive
<a name="java-getstarted-next"></a>

Quando disponi di un'applicazione in esecuzione in un ambiente, puoi [distribuire una nuova versione](using-features.deploy-existing-version.md) dell'applicazione o un'applicazione completamente diversa in qualsiasi momento. La distribuzione di una nuova versione dell'applicazione è molto veloce perché non richiede il provisioning o il riavvio delle istanze EC2.

Se, dopo aver distribuito una o due applicazioni di esempio, ti senti pronto per iniziare a sviluppare e a eseguire applicazioni Java in locale, consulta [la sezione successiva](java-development-environment.md) per impostare un ambiente di sviluppo Java con tutti gli strumenti e le librerie di cui hai bisogno.

# Utilizzo della piattaforma Tomcat di Elastic Beanstalk
<a name="java-tomcat-platform"></a>

Questo argomento descrive come configurare, creare ed eseguire le applicazioni Java eseguite sulla piattaforma Elastic Beanstalk Tomcat.

La piattaforma AWS Elastic Beanstalk Tomcat è un insieme di [versioni della piattaforma](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.java) per applicazioni Web Java che possono essere eseguite in un contenitore Web Tomcat. Tomcat viene eseguito dietro un server proxy nginx. Ogni ramo della piattaforma corrisponde a una versione principale di Tomcat.

Sono disponibili opzioni di configurazione specifiche della piattaforma nella console Elastic Beanstalk per la [modifica della configurazione di un ambiente in esecuzione](environment-configuration-methods-after.md). Per conservare la configurazione dell'ambiente una volta terminata, puoi utilizzare [configurazioni salvate](environment-configuration-savedconfig.md) per salvare le impostazioni e applicarle successivamente a un altro ambiente.

Per salvare le impostazioni nel codice sorgente, puoi includere i [file di configurazione](ebextensions.md). Le impostazioni nei file di configurazione vengono applicate ogni volta che crei un ambiente o distribuisci l'applicazione. Puoi inoltre utilizzare i file di configurazione per installare pacchetti, eseguire script o altre operazioni di personalizzazione delle istanze durante le distribuzioni.

La piattaforma Tomcat di Elastic Beanstalk include un proxy inverso che inoltra le richieste alla tua applicazione. È possibile utilizzare le [opzioni di configurazione](#java-tomcat-namespaces) per configurare il server proxy in modo che possa servire asset statici da una cartella nel codice sorgente, per ridurre il carico sull'applicazione. Per gli scenari avanzati, puoi [includere file `.conf` personalizzati](java-tomcat-proxy.md) nel bundle di origine per estendere la configurazione proxy di Elastic Beanstalk o sovrascriverla completamente.

**Nota**  
Elastic Beanstalk supporta [nginx](https://www.nginx.com/) (impostazione predefinita) e [Apache HTTP Server](https://httpd.apache.org/) come server proxy sulla piattaforma Tomcat. Se il tuo ambiente Tomcat di Elastic Beanstalk utilizza un ramo della piattaforma AMI Amazon Linux (precedente ad Amazon Linux 2), hai anche la possibilità di utilizzare [Apache HTTP Server versione 2.2](https://httpd.apache.org/docs/2.2/). Apache (versione più recente) è l'impostazione predefinita su questi rami della piattaforma più vecchi.   
 [Il 18 luglio 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk ha impostato lo stato di tutte le filiali della piattaforma basate su Amazon Linux AMI AL1 () come ritirato.** Per ulteriori informazioni sulla migrazione a una ramificazione della piattaforma Amazon Linux 2023 attuale e completamente supportata, consulta [Migrazione dell'applicazione Elastic Beanstalk Linux ad Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).

Devi creare un pacchetto di applicazioni Java in un file WAR con una struttura specifica. Per informazioni sulla struttura necessaria e sulla relazione con la struttura della tua directory di progetto, consulta [Strutturazione della cartella di progetto](java-tomcat-platform-directorystructure.md).

Per eseguire più applicazioni sullo stesso server Web, puoi [raggruppare più file WAR](java-tomcat-multiple-war-files.md) in un singolo bundle di origine. Ogni applicazione in un bundle di origine con più file WAR viene eseguita nel percorso root (`ROOT.war` eseguito in `myapp.elasticbeanstalk.com/`) o in un percorso immediatamente sottostante (`app2.war` eseguito in `myapp.elasticbeanstalk.com/app2/`), come indicato dal nome del file WAR. In un bundle di origine con un solo file WAR, l'applicazione viene eseguita sempre nel percorso root.

Le impostazioni applicate nella console Elastic Beanstalk sostituiscono le stesse impostazioni nei file di configurazione, se esistenti. Ciò ti consente di disporre di impostazioni predefinite nei file di configurazione, sostituibili con impostazioni specifiche per l'ambiente nella console. Per ulteriori informazioni sulla precedenza e altri metodi di modifica delle impostazioni, consulta [Opzioni di configurazione](command-options.md).

Per informazioni dettagliate sui vari modi in cui è possibile estendere una piattaforma Elastic Beanstalk basata su Linux, consulta [Estensione delle piattaforme Elastic Beanstalk Linux](platforms-linux-extend.md).

**Topics**
+ [

## Configurazione dell'ambiente Tomcat
](#java-tomcat-options)
+ [

## Spazio dei nomi della configurazione Tomcat
](#java-tomcat-namespaces)
+ [

# Raggruppamento di più file WAR per ambienti Tomcat
](java-tomcat-multiple-war-files.md)
+ [

# Strutturazione della cartella di progetto
](java-tomcat-platform-directorystructure.md)
+ [

# Configurazione del server proxy
](java-tomcat-proxy.md)

## Configurazione dell'ambiente Tomcat
<a name="java-tomcat-options"></a>

La piattaforma Tomcat di Elastic Beanstalk offre alcune opzioni specifiche della piattaforma in aggiunta alle opzioni standard disponibili in tutte le piattaforme. Queste opzioni permettono di configurare Java Virtual Machine (JVM), in esecuzione nei server Web dell'ambiente, e di definire proprietà di sistema che forniscono le stringhe di configurazione delle informazioni all'applicazione.

Puoi utilizzare la console Elastic Beanstalk per attivare la rotazione dei log in Amazon S3 e configurare variabili che l'applicazione è in grado di leggere dall'ambiente.

**Per configurare l'ambiente Tomcat nella console Elastic Beanstalk**

1. Apri la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) e, **nell'elenco Regioni, seleziona la tua**. Regione AWS

1. Nel pannello di navigazione selezionare **Environments** (Ambienti), quindi selezionare il nome dell'ambiente dall'elenco.

1. Nel riquadro di navigazione, seleziona **Configuration** (Configurazione).

1. Nella categoria di configurazione **Updates, monitoring, and logging** (Aggiornamenti, monitoraggio e registrazione), scegli **Edit** (Modifica).

### Opzioni del contenitore
<a name="java-tomcat-options-container"></a>

È possibile specificare le seguenti opzioni specifiche della piattaforma:
+ **Proxy server (Server proxy)**: il server proxy da utilizzare nelle istanze dell'ambiente. Per impostazione predefinita, viene utilizzato nginx.

### Opzioni del container JVM
<a name="java-tomcat-options-jvm"></a>

La dimensione heap nella Java Virtual Machine (JVM) determina il numero di oggetti che la tua applicazione può creare in memoria prima della *[garbage collection](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/introduction.html)*. Puoi modificare le opzioni **Dimensione heap iniziale di JVM** (`-Xms option`) e **Dimensione heap JVM massima** (`-Xmx`). Una dimensione heap iniziale più grande consente la creazione di un maggior numero di oggetti prima della garbage collection, ma il garbage collector impiegherà più tempo per compattare l'heap. La dimensione heap massima specifica la quantità massima di memoria che JVM può allocare durante l'espansione dell'heap nel quadro di un'attività intensa.

**Nota**  
La memoria disponibile dipende dal tipo di istanza Amazon EC2. Per ulteriori informazioni sui tipi di istanza EC2 disponibili per l'ambiente Elastic Beanstalk, consulta [Tipi di istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) nella *Guida per l'utente di Amazon Elastic Compute Cloud per istanze Linux*.

La *generazione permanente* è una sezione dell'heap JVM che memorizza le definizioni di classi e i metadati associati. Per modificare la dimensione della generazione permanente, digita la nuova dimensione nell'opzione **Maximum JVM PermGen Size** (`-XX:MaxPermSize`). Questa impostazione è valida solo per Java 7 e versioni precedenti. **Questa opzione era obsoleta in JDK 8 e sostituita dall'opzione Size (). MaxMetaspace** `-XX:MaxMetaspaceSize`

**Importante**  
JDK 17 ha rimosso il supporto dell'opzione Java `-XX:MaxPermSize`. L'utilizzo di questa opzione con un ambiente in esecuzione su una ramificazione della piattaforma Elastic Beanstalk con Corretto 17 genererà un errore. Elastic Beanstalk ha rilasciato la prima ramificazione della piattaforma che esegue Tomcat con Corretto 17 il [13 luglio 2023](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2023-07-13-al2023.html).  
Per ulteriori informazioni, consulta le risorse seguenti.  
Sito Web della documentazione di Oracle Java: [Removed Java Options](https://docs.oracle.com/en/java/javase/17/docs/specs/man/java.html#removed-java-options) 
Sito Web della documentazione di Oracle Java: sezione *Class Metadata* in [Other Considerations](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/considerations.html)

Per ulteriori informazioni sulle piattaforme Elastic Beanstalk e sui relativi componenti, consulta la pagina [Piattaforme supportate](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html) nella *Guida alle piattaforme AWS Elastic Beanstalk *.

### Opzioni di log
<a name="java-tomcat-options-logs"></a>

La sezione **Log Options (Opzioni di log)** ha due impostazioni:
+ **Instance profile** (Profilo dell'istanza): specifica il profilo dell'istanza che dispone dell'autorizzazione ad accedere al bucket Amazon S3 associato all'applicazione.
+ **Enable log file rotation to Amazon S3** (Abilita rotazione file di log in Amazon S3): specifica se i file di log per le istanze Amazon EC2 dell'applicazione debbano essere copiati nel bucket Amazon S3 associato all'applicazione.

### File statici
<a name="java-tomcat-options-staticfiles"></a>

Per migliorare le prestazioni, la sezione **Static files** (File statici) consente di configurare il server proxy affinché fornisca file statici (ad esempio, HTML o immagini) da un set di directory all'interno dell'applicazione Web. Per ogni directory, è possibile impostare il percorso virtuale per la mappatura delle directory. Quando il server proxy riceve una richiesta da un file nel percorso specificato, questo serve il file direttamente anziché instradare la richiesta all'applicazione.

Per informazioni dettagliate sulla configurazione di file statici utilizzando file di configurazione o la console Elastic Beanstalk, consulta [Fornire i file statici](environment-cfg-staticfiles.md).

### Proprietà dell'ambiente
<a name="java-tomcat-options-properties"></a>

Nella sezione **Environment Properties (Proprietà ambiente)** puoi specificare le impostazioni di configurazione dell'ambiente nelle istanze Amazon EC2 che eseguono l'applicazione. Le proprietà di ambiente sono passate come coppie chiave-valore all'applicazione. 

La piattaforma Tomcat definisce una proprietà segnaposto denominata `JDBC_CONNECTION_STRING` per gli ambienti Tomcat, utilizzata per passare una stringa di connessione a un database esterno.

**Nota**  
Se colleghi un'istanza database RDS all'ambiente, crea dinamicamente la stringa di connessione JDBC dalle proprietà dell'ambiente Amazon Relational Database Service (Amazon RDS) fornite da Elastic Beanstalk. Utilizza JDBC\$1CONNECTION\$1STRING solo per le istanze database il cui provisioning non viene effettuato mediante Elastic Beanstalk.  
Per ulteriori informazioni sull'uso di Amazon RDS con l'applicazione Java, consulta [Aggiungere un'istanza Amazon RDS DB all'ambiente Java Elastic Beanstalk](java-rds.md).

Per le versioni della piattaforma Tomcat rilasciate prima del [26 marzo 2025,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2025-03-26-windows.html) le variabili di ambiente sono accessibili tramite. `System.getProperty()` Ad esempio, è possibile leggere una proprietà denominata `API_ENDPOINT` da una variabile con il codice seguente.

```
String endpoint = System.getProperty("API_ENDPOINT");
```

Le versioni della piattaforma Tomcat rilasciate a partire [dal 26 marzo 2025](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2025-03-26-windows.html) possono essere utilizzate anche `System.getenv` per accedere a variabili di ambiente in testo non crittografato. È possibile continuare a utilizzare per accedere alle variabili di ambiente in testo `System.getProperty` non crittografato. Tuttavia, [le variabili di ambiente memorizzate come segrete](AWSHowTo.secrets.env-vars.md) sono disponibili solo utilizzando. `System.getenv` Ad esempio, è possibile leggere una variabile di ambiente denominata `API_KEY` con il codice seguente.

```
String apiKey = System.getenv("API_KEY");
```

**Importante**  
L'aggiunta dell'`System.getenv()`accesso per le variabili di ambiente nelle versioni della piattaforma Tomcat rilasciate il o dopo il [26 marzo 2025](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2025-03-26-windows.html) può causare comportamenti imprevisti nelle applicazioni che attribuiscono alle variabili di ambiente la precedenza sulle proprietà del sistema Java o quando si passa esplicitamente da a. `System.getProperty()` `System.getenv()`  
Poiché le proprietà di sistema (passate tramite riga di comando) richiedono l'escape della shell per i caratteri speciali mentre le variabili di ambiente no, i valori possono essere risolti in modo diverso quando si utilizzano le variabili di ambiente anziché le proprietà di sistema Java.  
Se la tua applicazione è interessata, considera:  
Rimozione dei caratteri di escape dai valori delle proprietà dell'ambiente durante l'utilizzo `System.getenv()`
Configurazione dell'applicazione per l'uso esplicito `System.getProperty()`
Verifica a fondo l'applicazione durante l'aggiornamento per garantire un comportamento coerente

Per ulteriori informazioni, consulta [Variabili di ambiente e altre impostazioni software](environments-cfg-softwaresettings.md).

## Spazio dei nomi della configurazione Tomcat
<a name="java-tomcat-namespaces"></a>

Puoi utilizzare un [file di configurazione](ebextensions.md) per impostare le opzioni di configurazione ed eseguire alte attività di configurazione delle istanze durante le distribuzioni. Le opzioni di configurazione possono essere [specifiche della piattaforma](command-options-specific.md) o essere applicate a [tutte le piattaforme](command-options-general.md) del servizio Elastic Beanstalk nel suo complesso. *Le opzioni di configurazione sono organizzate in namespace.*

Oltre alle [opzioni supportate per tutti gli ambienti Elastic Beanstalk](command-options-general.md), la piattaforma Tomcat supporta quelle incluse negli spazi dei nomi seguenti:
+ `aws:elasticbeanstalk:container:tomcat:jvmoptions`: modifica le impostazioni JVM. Le opzioni in questo spazio dei nomi corrispondono a quelle nella console di gestione, in questo modo:
  + `Xms` – **JVM command line options (Opzioni della riga di comando JVM**
  + `JVM Options` – **JVM command line options (Opzioni della riga di comando JVM**
+ `aws:elasticbeanstalk:environment:proxy`: scegli il server proxy dell'ambiente.

L'esempio di file di configurazione seguente mostra l'utilizzo delle opzioni di configurazione specifiche di Tomcat.

**Example .ebextensions/tomcat-settings.config**  

```
option_settings:
  aws:elasticbeanstalk:container:tomcat:jvmoptions:
    Xms: 512m
    JVM Options: '-Xmn128m'
  aws:elasticbeanstalk:application:environment:
    API_ENDPOINT: mywebapi.zkpexsjtmd.us-west-2.elasticbeanstalk.com
  aws:elasticbeanstalk:environment:proxy:
    ProxyServer: apache
```

In Elastic Beanstalk sono disponibili varie opzioni di configurazione per la personalizzazione dell'ambiente. Oltre ai file di configurazione, puoi impostare le opzioni di configurazione tramite la console, le configurazioni salvate, la CLI EB o AWS CLI. Per ulteriori informazioni, consulta [Opzioni di configurazione](command-options.md).

## La piattaforma Tomcat di AMI Amazon Linux (precedente ad Amazon Linux 2)
<a name="tomcat.alami"></a>

Se il tuo ambiente Tomcat di Elastic Beanstalk utilizza una versione della piattaforma AMI Amazon Linux (precedente Amazon Linux 2), leggi le informazioni aggiuntive presenti in questa sezione.

**Note**  
Le informazioni contenute in questo argomento si applicano solo ai rami della piattaforma basati su Amazon Linux AMI (AL1). AL2023I rami AL2 della piattaforma/sono incompatibili con le versioni precedenti della piattaforma Amazon Linux AMI (AL1) e *richiedono impostazioni di configurazione diverse*.
 [Il 18 luglio 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk ha impostato lo stato di tutte le filiali della piattaforma basate su Amazon Linux AMI AL1 () come ritirato.** Per ulteriori informazioni sulla migrazione a una ramificazione della piattaforma Amazon Linux 2023 attuale e completamente supportata, consulta [Migrazione dell'applicazione Elastic Beanstalk Linux ad Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).

### Namespace di configurazione Tomcat — Amazon Linux AMI () AL1
<a name="tomcat.alami.namespaces"></a>

La piattaforma Tomcat di AMI Amazon Linux supporta opzioni aggiuntive nei seguenti spazi dei nomi:
+ `aws:elasticbeanstalk:container:tomcat:jvmoptions`: oltre alle opzioni menzionate in precedenza in questa pagina per questo spazio dei nomi, le versioni precedenti della piattaforma AMI Amazon Linux supportano anche:
  + `XX:MaxPermSize` – **Maximum JVM permanent generation size (Dimensione massima di generazione permanente JVM**
+ `aws:elasticbeanstalk:environment:proxy`: oltre a scegliere il server proxy, configura anche la compressione delle risposte.

L'esempio di file di configurazione seguente mostra l'utilizzo delle opzioni di configurazione dello spazio dei nomi proxy.

**Example .ebextensions/tomcat-settings.config**  

```
option_settings:
  aws:elasticbeanstalk:environment:proxy:
    GzipCompression: 'true'
    ProxyServer: nginx
```

### Includi i file di configurazione di Elastic Beanstalk — Amazon Linux AMI () AL1
<a name="java-tomcat-ebextensions"></a>

Per distribuire i file di configurazione `.ebextensions`, occorre includerli nella sorgente dell'applicazione. Per una singola applicazione, aggiungi `.ebextensions` a un file WAR compresso eseguendo il seguente comando:

**Example**  

```
zip -ur your_application.war .ebextensions
```

Per un'applicazione che richiede più file WAR, consulta [Raggruppamento di più file WAR per ambienti Tomcat](java-tomcat-multiple-war-files.md) per ulteriori informazioni.

# Raggruppamento di più file WAR per ambienti Tomcat
<a name="java-tomcat-multiple-war-files"></a>

Se la tua app Web comprende più componenti dell'applicazione Web, è possibile semplificare le distribuzioni e ridurre i costi operativi tramite l'esecuzione di componenti in un singolo ambiente, invece di eseguire un ambiente separato per ogni componente. Questa strategia è efficace per applicazioni leggere che non necessitano di una notevole quantità di risorse e per ambienti di sviluppo e test.

Per distribuire più applicazioni Web nell'ambiente, combina i file WAR (Web Application Archive) di ogni componente in un singolo [bundle di origine](applications-sourcebundle.md).

Per creare un bundle di origine dell'applicazione che contenga più file WAR, organizza i file WAR utilizzando la seguente struttura.

```
MyApplication.zip
├── .ebextensions
├── .platform
├── foo.war
├── bar.war
└── ROOT.war
```

Quando si distribuisce un pacchetto sorgente contenente più file WAR in un AWS Elastic Beanstalk ambiente, ogni applicazione è accessibile da un percorso diverso dal nome di dominio principale. L'esempio precedente include tre applicazioni: `foo`, `bar` e `ROOT`. `ROOT.war` è uno speciale nome di file che indica a Elastic Beanstalk di eseguire l'applicazione nel dominio radice, in modo che le tre applicazioni siano disponibili in `http://MyApplication.elasticbeanstalk.com/foo`, `http://MyApplication.elasticbeanstalk.com/bar` e `http://MyApplication.elasticbeanstalk.com`.

Il bundle di origine può includere file WAR, una cartella opzionale `.ebextensions` e una cartella opzionale `.platform`. Per informazioni dettagliate su queste cartelle di configurazione facoltative, consulta [Estensione delle piattaforme Elastic Beanstalk Linux](platforms-linux-extend.md).

**Per avviare un ambiente (console)**

1. [Apri la console Elastic Beanstalk con questo link preconfigurato: console.aws.amazon. com/elasticbeanstalk/home\$1/newApplication? ApplicationName=Tutorials&EnvironmentType= LoadBalanced](https://console.aws.amazon.com/elasticbeanstalk/home#/newApplication?applicationName=tutorials&environmentType=LoadBalanced)

1. Per **Platform (Piattaforma)**, selezionare la piattaforma e il ramo della piattaforma corrispondenti al linguaggio utilizzato dall'applicazione o la piattaforma Docker per le applicazioni basate su container.

1. Per **Application code (Codice applicazione)**, scegliere **Carica il tuo codice**.

1. Selezionare **Local file (File locale)**, quindi **Browse (Sfoglia)** e aprire il bundle di origine.

1. Selezionare **Review and launch (Controlla e avvia)**.

1. Controlla le impostazioni disponibili, quindi seleziona **Create app (Crea applicazione)**.

Per ulteriori informazioni su come creare bundle di origine, consulta [Crea un bundle di sorgenti dell'applicazione Elastic Beanstalk](applications-sourcebundle.md).

# Strutturazione della cartella di progetto
<a name="java-tomcat-platform-directorystructure"></a>

Per poter funzionare quando vengono distribuiti in un server Tomcat, gli archivi dell'applicazione Web (file WAR) Java Platform Enterprise Edition (*Java EE*) compilati devono essere strutturati in base a determinate [linee guida](https://docs.oracle.com/javaee/7/tutorial/packaging003.htm). La directory di progetto non deve necessariamente soddisfare gli stessi standard, ma è una buona idea strutturarla allo stesso modo per semplificare la compilazione e la creazione di pacchetti. La strutturazione della cartella di progetto come contenuto di file WAR, inoltre, aiuta a comprendere la relazione tra i file e il relativo comportamento su un server Web.

Nella seguente gerarchia consigliata il codice sorgente per l'applicazione Web viene posizionato in una directory `src`, in modo da isolarlo dallo script di creazione e dal file WAR che genera.

```
~/workspace/my-app/
|-- build.sh            - Build script that compiles classes and creates a WAR
|-- README.MD           - Readme file with information about your project, notes
|-- ROOT.war            - Source bundle artifact created by build.sh
`-- src                 - Source code folder
    |-- WEB-INF         - Folder for private supporting files
    |   |-- classes     - Compiled classes
    |   |-- lib         - JAR libraries
    |   |-- tags        - Tag files
    |   |-- tlds        - Tag Library Descriptor files
    |   `-- web.xml     - Deployment Descriptor
    |-- com             - Uncompiled classes
    |-- css             - Style sheets
    |-- images          - Image files
    |-- js              - JavaScript files
    `-- default.jsp     - JSP (JavaServer Pages) webpage
```

Il contenuto della cartella `src` corrisponde a ciò che verrà inserito in pacchetti e distribuito al server, ad eccezione della cartella `com`. La cartella `com` contiene le classi non compilate (file `.java`). Queste devono essere compilate e inserite nella directory `WEB-INF/classes` per essere accessibili dal codice dell'applicazione.

La directory `WEB-INF` contiene il codice e le configurazioni che non vengono gestiti pubblicamente nel server Web. Le altre cartelle nella root della directory di origine (`css`, `images` e `js`) sono disponibili pubblicamente nel percorso corrispondente nel server Web.

L'esempio seguente è identico alla directory di progetto precedente, ma contiene ulteriori file e sottodirectory. Questo progetto di esempio include tag semplici, classi di supporto e modello e un file Java Server Page (JSP) per una risorsa `record`. Include anche un foglio di stile e JavaScript per [Bootstrap](http://getbootstrap.com/), un file JSP predefinito e una pagina di errore per gli errori 404.

`WEB-INF/lib` include un file Java Archive (JAR) che contiene il driver Java Database Connectivity (JDBC) per PostgreSQL. `WEB-INF/classes` è vuoto perché i file di classe non sono ancora state compilate.

```
~/workspace/my-app/
|-- build.sh
|-- README.MD
|-- ROOT.war
`-- src
    |-- WEB-INF
    |   |-- classes
    |   |-- lib
    |   |   `-- postgresql-9.4-1201.jdbc4.jar
    |   |-- tags
    |   |   `-- header.tag
    |   |-- tlds
    |   |   `-- records.tld
    |   `-- web.xml
    |-- com
    |   `-- myapp
    |       |-- model
    |       |   `-- Record.java
    |       `-- web
    |           `-- ListRecords.java
    |-- css
    |   |-- bootstrap.min.css
    |   `-- myapp.css
    |-- images
    |   `-- myapp.png
    |-- js
    |   `-- bootstrap.min.js
    |-- 404.jsp
    |-- default.jsp
    `-- records.jsp
```

## Creazione di un file WAR con uno script di shell
<a name="java-tomcat-platform-directorystructure-building"></a>

`build.sh` è uno script di shell molto semplice che compila classi Java, crea un file WAR e lo copia nella directory `webapps` di Tomcat per test locali.

```
cd src
javac -d WEB-INF/classes com/myapp/model/Record.java
javac -classpath WEB-INF/lib/*:WEB-INF/classes -d WEB-INF/classes com/myapp/model/Record.java
javac -classpath WEB-INF/lib/*:WEB-INF/classes -d WEB-INF/classes com/myapp/web/ListRecords.java

jar -cvf ROOT.war *.jsp images css js WEB-INF
cp ROOT.war /Library/Tomcat/webapps
mv ROOT.war ../
```

All'interno del file WAR troverai la stessa struttura esistente nella directory `src` dell'esempio precedente, esclusa la cartella `src/com`. Il comando `jar` crea automaticamente il file `META-INF/MANIFEST.MF`.

```
~/workspace/my-app/ROOT.war
|-- META-INF
|   `-- MANIFEST.MF
|-- WEB-INF
|   |-- classes
|   |   `-- com
|   |       `-- myapp
|   |           |-- model
|   |           |   `-- Records.class
|   |           `-- web
|   |               `-- ListRecords.class
|   |-- lib
|   |   `-- postgresql-9.4-1201.jdbc4.jar
|   |-- tags
|   |   `-- header.tag
|   |-- tlds
|   |   `-- records.tld
|   `-- web.xml
|-- css
|   |-- bootstrap.min.css
|   `-- myapp.css
|-- images
|   `-- myapp.png
|-- js
|   `-- bootstrap.min.js
|-- 404.jsp
|-- default.jsp
`-- records.jsp
```

## Utilizzo `.gitignore`
<a name="java-tomcat-platform-gitignore"></a>

Per evitare il commit dei file di classe e dei file WAR compilati nel repository Git o la visualizzazione di messaggi relativi a questi file quando esegui comandi Git, aggiungi i tipi di file rilevanti a un file denominato `.gitignore` nella cartella di progetto.

**\$1/workspace/myapp/.gitignore**

```
*.zip
*.class
```

# Configurazione del server proxy
<a name="java-tomcat-proxy"></a>

La piattaforma Tomcat utilizza [nginx](https://www.nginx.com/) (impostazione predefinita) o [Apache HTTP Server](https://httpd.apache.org/) come proxy inverso per inoltrare le richieste dalla porta 80 dell'istanza al container Web Tomcat in ascolto sulla porta 8080. Elastic Beanstalk fornisce una configurazione proxy predefinita che puoi estendere o sostituire completamente a favore di quella personalizzata.

**Configurazione del server proxy sulla versione della piattaforma**  
Tutte le AL2 piattaforme AL2023/supportano una funzionalità di configurazione proxy uniforme. Per ulteriori informazioni sulla configurazione del server proxy sulle versioni della piattaforma che eseguono AL2023/AL2, consulta[Configurazione del proxy inverso](platforms-linux-extend.proxy.md). 

## Configurazione del proxy sulla piattaforma Tomcat di AMI Amazon Linux (precedente ad Amazon Linux 2)
<a name="java-tomcat-proxy.alami"></a>

Se il tuo ambiente Tomcat di Elastic Beanstalk utilizza una versione della piattaforma AMI Amazon Linux (precedente Amazon Linux 2), leggi le informazioni aggiuntive presenti in questa sezione.

**Note**  
Le informazioni contenute in questo argomento si applicano solo ai rami della piattaforma basati su Amazon Linux AMI (AL1). AL2023I rami AL2 della piattaforma/sono incompatibili con le versioni precedenti della piattaforma Amazon Linux AMI (AL1) e *richiedono impostazioni di configurazione diverse*.
 [Il 18 luglio 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk ha impostato lo stato di tutte le filiali della piattaforma basate su Amazon Linux AMI AL1 () come ritirato.** Per ulteriori informazioni sulla migrazione a una ramificazione della piattaforma Amazon Linux 2023 attuale e completamente supportata, consulta [Migrazione dell'applicazione Elastic Beanstalk Linux ad Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).

### Scelta di un server proxy per il tuo ambiente Tomcat — Amazon Linux AMI () AL1
<a name="java-tomcat-proxy.alami"></a>

Le versioni della piattaforma Tomcat basate su AMI Amazon Linux (precedente ad Amazon Linux 2) utilizzano per impostazione predefinita [Apache 2.4](https://httpd.apache.org/docs/2.4/) per il proxy. Puoi scegliere di usare [Apache 2.2](https://httpd.apache.org/docs/2.2/) o [nginx](https://www.nginx.com/) includendo un [file di configurazione](ebextensions.md) nel codice sorgente. L'esempio seguente configura Elastic Beanstalk per l'uso di nginx.

**Example .ebextensions/nginx-proxy.config**  

```
option_settings:
  aws:elasticbeanstalk:environment:proxy:
    ProxyServer: nginx
```

### Migrazione da Apache 2.2 ad Apache 2.4 — Amazon Linux AMI () AL1
<a name="java-tomcat-proxy-apache-migrate"></a>

Se l'applicazione è stata sviluppata per [Apache 2.2](https://httpd.apache.org/docs/2.2/), leggi questa sezione per informazioni sulla migrazione ad [Apache 2.4](https://httpd.apache.org/docs/2.4/).

A partire dalle configurazioni della piattaforma Tomcat versione 3.0.0, rese disponibili con [l'aggiornamento della piattaforma Java con Tomcat del 24 maggio 2018](https://aws.amazon.com/releasenotes/release-aws-elastic-beanstalk-platform-update-for-the-java-with-tomcat-platform-on-may-24-2018/), Apache 2.4 è il proxy predefinito della piattaforma Tomcat. I file `.conf` di Apache 2.4 sono in gran parte, ma non interamente, compatibili con quelli della versione Apache 2.2 precedente. Elastic Beanstalk include file `.conf` predefiniti che funzionano correttamente con ogni versione di Apache. Se la tua applicazione non personalizza la configurazione di Apache, come descritto in [Estensione e sovrascrittura della configurazione predefinita di Apache — Amazon Linux AMI () AL1](#java-tomcat-proxy-apache), dovrebbe supportare la migrazione ad Apache 2.4 senza problemi.

Se l'applicazione estende o sostituisce la configurazione di Apache, potrebbe essere necessario effettuare alcune modifiche per migrare ad Apache 2.4. Per ulteriori informazioni, consulta la pagina relativa all'[aggiornamento alla versione 2.4 dalla 2.2](https://httpd.apache.org/docs/current/upgrading.html) sul sito *Apache Software Foundation*. Finché non esegui la migrazione ad Apache 2.4, come misura temporanea puoi scegliere di usare Apache 2.2 con l'applicazione includendo il [file di configurazione](ebextensions.md) seguente nel codice sorgente.

**Example apache-legacy-proxy.ebextensions/ .config**  

```
option_settings:
  aws:elasticbeanstalk:environment:proxy:
    ProxyServer: apache/2.2
```

Per una soluzione rapida, puoi anche selezionare il server proxy nella console Elastic Beanstalk.

**Per selezionare il proxy nell'ambiente Tomcat nella console Elastic Beanstalk**

1. Apri la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) e, **nell'elenco Regioni, seleziona la tua**. Regione AWS

1. Nel pannello di navigazione selezionare **Environments** (Ambienti), quindi selezionare il nome dell'ambiente dall'elenco.

1. Nel riquadro di navigazione, seleziona **Configuration** (Configurazione).

1. Nella categoria di configurazione **Updates, monitoring, and logging** (Aggiornamenti, monitoraggio e registrazione), scegli **Edit** (Modifica).

1. In **Proxy server (Server proxy)** scegli `Apache 2.2 (deprecated)`.

1. Per salvare le modifiche scegli **Apply** (Applica) nella parte inferiore della pagina.

![\[Selezione del proxy per un ambiente Tomcat nella categoria di configurazione software della console Elastic Beanstalk\]](http://docs.aws.amazon.com/it_it/elasticbeanstalk/latest/dg/images/java-tomcat-proxy-selection.png)


### Estensione e sovrascrittura della configurazione predefinita di Apache — Amazon Linux AMI () AL1
<a name="java-tomcat-proxy-apache"></a>

Puoi estendere la configurazione Apache predefinita di Elastic Beanstalk con file di configurazione personalizzati aggiuntivi. In alternativa, puoi sostituire completamente la configurazione Apache predefinita di Elastic Beanstalk.

**Nota**  
Tutte le piattaforme Amazon Linux 2 supportano una caratteristica di configurazione proxy uniforme. Per informazioni dettagliate sulla configurazione del server proxy sulle versioni della piattaforma Tomcat che eseguono Amazon Linux 2, consulta. [Configurazione del proxy inverso](platforms-linux-extend.proxy.md)
Se stai eseguendo la migrazione dell'applicazione Elastic Beanstalk a una piattaforma Amazon Linux 2, leggi anche le informazioni in [Migrazione dell'applicazione Elastic Beanstalk Linux ad Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).

Per estendere la configurazione Apache predefinita di Elastic Beanstalk, aggiungi i file di configurazione `.conf` a una cartella denominata `.ebextensions/httpd/conf.d` nel bundle di origine dell'applicazione. La configurazione Apache di Elastic Beanstalk include automaticamente i file `.conf` in questa cartella.

```
~/workspace/my-app/
|-- .ebextensions
|   -- httpd
|      -- conf.d
|         -- myconf.conf
|         -- ssl.conf
-- index.jsp
```

Ad esempio, la configurazione Apache 2.4 seguente aggiunge un listener sulla porta 5000.

**Example . ebextensions/httpd/conf.d/port5000. conf**  

```
listen 5000
<VirtualHost *:5000>
  <Proxy *>
    Require all granted
  </Proxy>
  ProxyPass / http://localhost:8080/ retry=0
  ProxyPassReverse / http://localhost:8080/
  ProxyPreserveHost on

  ErrorLog /var/log/httpd/elasticbeanstalk-error_log
</VirtualHost>
```

Per sostituire completamente la configurazione Apache predefinita di Elastic Beanstalk, includi una configurazione nel bundle di origine in `.ebextensions/httpd/conf/httpd.conf`.

```
~/workspace/my-app/
|-- .ebextensions
|   `-- httpd
|       `-- conf
|           `-- httpd.conf
`-- index.jsp
```

Se vuoi sostituire completamente la configurazione Apache di Elastic Beanstalk, aggiungi le righe seguenti a `httpd.conf` per ottenere le configurazioni di Elastic Beanstalk per [Reportistica e monitoraggio dello stato di salute migliorati in Elastic Beanstalk](health-enhanced.md), la compressione delle risposte e i file statici.

```
IncludeOptional conf.d/*.conf
IncludeOptional conf.d/elasticbeanstalk/*.conf
```

Se l'ambiente usa Apache 2.2 come proxy, sostituisci le direttive `IncludeOptional` con `Include`. [Per dettagli sul comportamento di queste due direttive nelle due versioni di Apache, consultate [Include in Apache 2.4, in Apache 2.4](https://httpd.apache.org/docs/2.4/mod/core.html#include) e Include [IncludeOptional in Apache 2.2](https://httpd.apache.org/docs/2.4/mod/core.html#includeoptional).](https://httpd.apache.org/docs/2.2/mod/core.html#include)

**Nota**  
Per sostituire il listener predefinito sulla porta 80, includi un file denominato `00_application.conf` in `.ebextensions/httpd/conf.d/elasticbeanstalk/` per sovrascrivere la configurazione di Elastic Beanstalk.

Per un esempio di utilizzo, osserva il file di configurazione predefinito di Elastic Beanstalk in `/etc/httpd/conf/httpd.conf` in un'istanza nell'ambiente. Tutti i file della cartella `.ebextensions/httpd` nel bundle di origine vengono copiati in `/etc/httpd` durante le distribuzioni.

### Estensione della configurazione nginx predefinita — Amazon Linux AMI () AL1
<a name="java-tomcat-proxy-nginx"></a>

Per estendere la configurazione nginx predefinita di Elastic Beanstalk, aggiungi file di configurazione `.conf` in una cartella denominata `.ebextensions/nginx/conf.d/` nel bundle di origine dell'applicazione. La configurazione nginx di Elastic Beanstalk include automaticamente i file `.conf` in questa cartella.

```
~/workspace/my-app/
|-- .ebextensions
|   `-- nginx
|       `-- conf.d
|           |-- elasticbeanstalk
|           |   `-- my-server-conf.conf
|           `-- my-http-conf.conf
`-- index.jsp
```

I file con estensione .conf nella cartella `conf.d` vengono inclusi nel blocco `http` della configurazione predefinita. I file nella cartella `conf.d/elasticbeanstalk` vengono inclusi nel blocco `server` all'interno del blocco `http`.

Per sostituire completamente la configurazione nginx predefinita di Elastic Beanstalk, includi una configurazione nel bundle di origine in `.ebextensions/nginx/nginx.conf`.

```
~/workspace/my-app/
|-- .ebextensions
|   `-- nginx
|       `-- nginx.conf
`-- index.jsp
```

**Note**  
Se sostituisci la configurazione nginx di Elastic Beanstalk, aggiungi la riga seguente al blocco `server` della configurazione per ottenere le configurazioni di Elastic Beanstalk per il listener della porta 80, la compressione delle risposte e i file statici.  

  ```
   include conf.d/elasticbeanstalk/*.conf;
  ```
Per sostituire il listener predefinito sulla porta 80, includi un file denominato `00_application.conf` in `.ebextensions/nginx/conf.d/elasticbeanstalk/` per sovrascrivere la configurazione di Elastic Beanstalk.
Includi anche la riga seguente nel blocco `http` della configurazione per ottenere le configurazioni di Elastic Beanstalk per [Reportistica e monitoraggio dello stato di salute migliorati in Elastic Beanstalk](health-enhanced.md) e la registrazione.  

  ```
      include       conf.d/*.conf;
  ```

Per un esempio di utilizzo, osserva il file di configurazione predefinito di Elastic Beanstalk in `/etc/nginx/nginx.conf` in un'istanza nell'ambiente. Tutti i file della cartella `.ebextensions/nginx` nel bundle di origine vengono copiati in `/etc/nginx` durante le distribuzioni.

# Utilizzo della piattaforma Java SE di Elastic Beanstalk
<a name="java-se-platform"></a>

Questo argomento descrive come configurare, creare ed eseguire le applicazioni Java eseguite sulla piattaforma AWS Elastic Beanstalk Java SE.

La piattaforma Elastic Beanstalk Java SE è un [insieme di versioni della](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.javase) piattaforma per applicazioni Web Java che possono essere eseguite autonomamente da un file JAR compilato. Puoi compilare l'applicazione in locale o caricare il codice sorgente con uno script di compilazione per compilarlo nell'istanza. Le versioni della piattaforma Java SE sono raggruppate in rami della piattaforma, ognuno dei quali corrisponde a una versione principale di Java.

**Nota**  
Elastic Beanstalk non analizza il file JAR dell'applicazione. Mantieni i file necessari a Elastic Beanstalk all'esterno del file JAR. Ad esempio, è possibile includere il file `cron.yaml` di un [ambiente lavoratore](using-features-managing-env-tiers.md) nella radice del bundle di origine dell'applicazione, accanto al file JAR.

Sono disponibili opzioni di configurazione specifiche della piattaforma nella console Elastic Beanstalk per la [modifica della configurazione di un ambiente in esecuzione](environment-configuration-methods-after.md). Per conservare la configurazione dell'ambiente una volta terminata, puoi utilizzare [configurazioni salvate](environment-configuration-savedconfig.md) per salvare le impostazioni e applicarle successivamente a un altro ambiente.

Per salvare le impostazioni nel codice sorgente, puoi includere i [file di configurazione](ebextensions.md). Le impostazioni nei file di configurazione vengono applicate ogni volta che crei un ambiente o distribuisci l'applicazione. Puoi inoltre utilizzare i file di configurazione per installare pacchetti, eseguire script o altre operazioni di personalizzazione delle istanze durante le distribuzioni.

La piattaforma Java SE di Elastic Beanstalk include un server [nginx](https://www.nginx.com/) che funge da proxy inverso che fornisce i contenuti statici memorizzati nella cache e trasmette le richieste all'applicazione. La piattaforma offre opzioni di configurazione per configurare il server proxy per fornire asset statici da una cartella nel codice sorgente, in modo da ridurre il carico sull'applicazione. Per gli scenari avanzati, puoi [includere file .conf personalizzati](java-se-nginx.md) nel bundle di origine per estendere la configurazione proxy di Elastic Beanstalk o sovrascriverla completamente. 

Se fornisci solo un singolo file JAR per l'origine dell'applicazione (da solo, non all'interno di un bundle di origine), Elastic Beanstalk rinomina il tuo file JAR in `application.jar` e quindi lo esegue utilizzando `java -jar application.jar`. Per configurare i processi in esecuzione nelle istanze del server nell'ambiente, includi un oggetto [Procfile](java-se-procfile.md) opzionale nel bundle di origine. Un oggetto `Procfile` è obbligatorio se è presente più di un file JAR nella radice del bundle di origine o se desideri personalizzare il comando Java per l'impostazione delle opzioni JVM.

Si consiglia di fornire sempre un `Procfile` nel bundle di origine insieme all'applicazione. In questo modo si controlla con precisione quali processi vengono eseguiti da Elastic Beanstalk per l'applicazione e quali argomenti ricevono questi processi.

Per compilare le classi Java ed eseguire altri comandi di compilazione sulle EC2 istanze del tuo ambiente al momento della distribuzione, includi un [Buildfile](java-se-buildfile.md) nel bundle dei sorgenti dell'applicazione. A `Buildfile` consente di distribuire il codice sorgente così com'è e di compilarlo sul server anziché compilarlo localmente. JARs La piattaforma Java SE include strumenti di compilazione comuni per consentire la compilazione direttamente nel server.

Per informazioni dettagliate sui vari modi in cui è possibile estendere una piattaforma Elastic Beanstalk basata su Linux, consulta [Estensione delle piattaforme Elastic Beanstalk Linux](platforms-linux-extend.md).

## Configurazione dell'ambiente Java SE
<a name="java-se-options"></a>

Le impostazioni della piattaforma Java SE ti consentono di ottimizzare il comportamento delle tue istanze Amazon EC2 . Puoi modificare la configurazione dell'istanza Amazon dell'ambiente Elastic Beanstalk utilizzando EC2 la console Elastic Beanstalk.

Utilizza la console Elastic Beanstalk per attivare la rotazione dei log in Amazon S3 e configurare variabili che l'applicazione è in grado di leggere dall'ambiente.

**Per configurare l'ambiente Java SE nella console Elastic Beanstalk**

1. Apri la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) e, **nell'elenco Regioni, seleziona la tua**. Regione AWS

1. Nel pannello di navigazione selezionare **Environments** (Ambienti), quindi selezionare il nome dell'ambiente dall'elenco.

1. Nel riquadro di navigazione, seleziona **Configuration** (Configurazione).

1. Nella categoria di configurazione **Updates, monitoring, and logging** (Aggiornamenti, monitoraggio e registrazione), scegli **Edit** (Modifica).

### Opzioni di log
<a name="java-se-options-logs"></a>

La sezione Log Options (Opzioni di log) ha due impostazioni:
+ **Instance profile** (Profilo dell'istanza): specifica il profilo dell'istanza che dispone dell'autorizzazione ad accedere al bucket Amazon S3 associato all'applicazione.
+ **Abilita la rotazione dei file di registro su Amazon S3**: specifica se i file di log per le EC2 istanze Amazon dell'applicazione vengono copiati nel bucket Amazon S3 associato all'applicazione.

### File statici
<a name="java-se-options-staticfiles"></a>

Per migliorare le prestazioni, la sezione **Static files** (File statici) consente di configurare il server proxy affinché fornisca file statici (ad esempio, HTML o immagini) da un set di directory all'interno dell'applicazione Web. Per ogni directory, è possibile impostare il percorso virtuale per la mappatura delle directory. Quando il server proxy riceve una richiesta da un file nel percorso specificato, questo serve il file direttamente anziché instradare la richiesta all'applicazione.

Per informazioni dettagliate sulla configurazione di file statici utilizzando file di configurazione o la console Elastic Beanstalk, consulta [Fornire i file statici](environment-cfg-staticfiles.md).

### Proprietà dell'ambiente
<a name="java-se-options-properties"></a>

La sezione **Environment Properties** consente di specificare le impostazioni di configurazione dell'ambiente sulle EC2 istanze Amazon su cui è in esecuzione l'applicazione. Le proprietà di ambiente sono passate come coppie chiave-valore all'applicazione.

All'interno dell'ambiente Java SE in esecuzione in Elastic Beanstalk, le variabili di ambiente sono accessibili tramite `System.getenv()`. Ad esempio, è possibile leggere una proprietà denominata `API_ENDPOINT` su una variabile con il codice seguente:

```
String endpoint = System.getenv("API_ENDPOINT");
```

Per ulteriori informazioni, consulta [Variabili di ambiente e altre impostazioni software](environments-cfg-softwaresettings.md).

## Spazio dei nomi per la configurazione di Java SE
<a name="java-se-namespaces"></a>

Puoi utilizzare un [file di configurazione](ebextensions.md) per impostare le opzioni di configurazione ed eseguire alte attività di configurazione delle istanze durante le distribuzioni. Le opzioni di configurazione possono essere [specifiche della piattaforma](command-options-specific.md) o essere applicate a [tutte le piattaforme](command-options-general.md) del servizio Elastic Beanstalk nel suo complesso. *Le opzioni di configurazione sono organizzate in namespace.*

La piattaforma Java SE non definisce spazi dei nomi specifici della piattaforma. È possibile configurare il proxy per servire file statici utilizzando lo spazio dei nomi `aws:elasticbeanstalk:environment:proxy:staticfiles`. Per informazioni dettagliate e un esempio, consulta [Fornire i file statici](environment-cfg-staticfiles.md).

In Elastic Beanstalk sono disponibili varie opzioni di configurazione per la personalizzazione dell'ambiente. Oltre ai file di configurazione, puoi impostare le opzioni di configurazione tramite la console, le configurazioni salvate, la CLI EB o AWS CLI. Per ulteriori informazioni, consulta [Opzioni di configurazione](command-options.md).

## La piattaforma Java SE di AMI Amazon Linux (precedente ad Amazon Linux 2)
<a name="java-se.alami"></a>

Se il tuo ambiente Java SE di Elastic Beanstalk utilizza una versione della piattaforma AMI Amazon Linux (precedente Amazon Linux 2), leggi le informazioni aggiuntive presenti in questa sezione.

**Note**  
Le informazioni contenute in questo argomento si applicano solo ai rami della piattaforma basati su Amazon Linux AMI (AL1). AL2I rami della AL2 piattaforma 023/ non sono compatibili con le versioni precedenti della piattaforma Amazon Linux AMI (AL1) e *richiedono impostazioni di configurazione diverse*.
 [Il 18 luglio 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk ha impostato lo stato di tutte le filiali della piattaforma basate su Amazon Linux AMI AL1 () come ritirato.** Per ulteriori informazioni sulla migrazione a una ramificazione della piattaforma Amazon Linux 2023 attuale e completamente supportata, consulta [Migrazione dell'applicazione Elastic Beanstalk Linux ad Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).

### Namespace di configurazione Java SE — Amazon Linux AMI () AL1
<a name="java-se.alami.namespaces"></a>

È possibile utilizzare un [file di configurazione](ebextensions.md) per impostare le opzioni di configurazione ed eseguire alte attività di configurazione delle istanze durante le distribuzioni. Le opzioni di configurazione possono essere [specifiche della piattaforma](command-options-specific.md) o essere applicate a [tutte le piattaforme](command-options-general.md) del servizio Elastic Beanstalk nel suo complesso. *Le opzioni di configurazione sono organizzate in namespace.*

La piattaforma Java SE supporta uno spazio dei nomi di configurazione specifico della piattaforma, in aggiunta agli [spazi dei nomi supportati da tutte le piattaforme](command-options-general.md). Lo spazio dei nomi `aws:elasticbeanstalk:container:java:staticfiles` consente di definire le opzioni che mappano i percorsi nell'applicazione Web alle cartelle del bundle di origine dell'applicazione con contenuti statici.

Il frammento di codice [option\$1settings](ebextensions-optionsettings.md) definisce ad esempio due opzioni nello spazio dei nomi dei file statici. La prima mappa il percorso `/public` a una cartella denominata `public` e la seconda mappa il percorso `/images` a una cartella denominata `img`:

```
option_settings:
  aws:elasticbeanstalk:container:java:staticfiles:
    /html: statichtml
    /images: staticimages
```

Le cartelle mappate usando questo spazio dei nomi devono essere cartelle reali nella radice del bundle di origine. Non è possibile mappare un percorso a una cartella in un file JAR.

In Elastic Beanstalk sono disponibili varie opzioni di configurazione per la personalizzazione dell'ambiente. Oltre ai file di configurazione, puoi impostare le opzioni di configurazione tramite la console, le configurazioni salvate, la CLI EB o AWS CLI. Per ulteriori informazioni, consulta [Opzioni di configurazione](command-options.md).

# Creazione JARs su server con un Buildfile
<a name="java-se-buildfile"></a>

Puoi creare i file di classe e i file JAR dell'applicazione sulle EC2 istanze del tuo ambiente richiamando un comando build da un `Buildfile` file nel tuo bundle sorgente.

I comandi in un file `Buildfile` vengono eseguiti solo una volta e devono terminare al completamento, mentre i comandi in un [Procfile](java-se-procfile.md) vengono eseguiti per l'intera durata dell'applicazione e verranno riavviati se terminati. Per eseguirlo JARs nella tua applicazione, usa un. `Procfile`

Per informazioni dettagliate sul posizionamento e sulla sintassi di a`Buildfile`, vedere[Buildfile e Procfile](platforms-linux-extend.build-proc.md).

Nell'esempio `Buildfile` seguente viene eseguito Apache Maven per creare un'applicazione Web dal codice di origine. Consulta gli [esempi dell'applicazione Web Java](java-getstarted.md#java-getstarted-samples) per un'applicazione di esempio che utilizza questa funzionalità.

**Example Buildfile**  

```
build: mvn assembly:assembly -DdescriptorId=jar-with-dependencies
```

La piattaforma Java SE include i seguenti strumenti di build, che puoi chiamare dal tuo script di build:
+ `javac` - Java compiler
+ `ant` - Apache Ant
+ `mvn` - Apache Maven
+ `gradle` - Gradle

# Configurazione del processo dell'applicazione con un Procfile
<a name="java-se-procfile"></a>

Se disponi di più file JAR nella cartella principale del bundle di origine dell'applicazione, è necessario includere un file `Procfile` che indichi a Elastic Beanstalk quale/i JAR eseguire. È anche possibile includere un file `Procfile` per una singola applicazione JAR per configurare la macchina virtuale Java (JVM) che esegue la tua applicazione.

Si consiglia di fornire sempre un `Procfile` nel bundle di origine insieme all'applicazione. In questo modo si controlla con precisione quali processi vengono eseguiti da Elastic Beanstalk per l'applicazione e quali argomenti ricevono questi processi.

Per dettagli sulla scrittura e l'uso di un file, `Procfile` vedere[Buildfile e Procfile](platforms-linux-extend.build-proc.md).

**Example Procfile**  

```
web: java -Xms256m -jar server.jar 
cache: java -jar mycache.jar
web_foo: java -jar other.jar
```

Il comando che esegue lo JAR principale nella tua applicazione deve essere chiamato `web` e deve essere il primo comando elencato nel `Procfile`. Il server nginx inoltra tutte le richieste HTTP che riceve dal load balancer del tuo ambiente a questa applicazione.

Elastic Beanstalk presuppone che tutte le voci in Procfile siano eseguite in qualsiasi momento e riavvia automaticamente qualsiasi applicazione definita nel Procfile che viene terminato. Per eseguire comandi che termineranno e non devono essere riavviati, utilizza un [`Buildfile`](java-se-buildfile.md).

## Utilizzo di un Procfile su AMI Amazon Linux (precedente ad Amazon Linux 2)
<a name="java-se-procfile.alami"></a>

Se il tuo ambiente Java SE di Elastic Beanstalk utilizza una versione della piattaforma AMI Amazon Linux (precedente Amazon Linux 2), leggi le informazioni aggiuntive presenti in questa sezione.

**Note**  
Le informazioni contenute in questo argomento si applicano solo ai rami della piattaforma basati su Amazon Linux AMI (AL1). AL2I rami della AL2 piattaforma 023/ non sono compatibili con le versioni precedenti della piattaforma Amazon Linux AMI (AL1) e *richiedono impostazioni di configurazione diverse*.
 [Il 18 luglio 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk ha impostato lo stato di tutte le filiali della piattaforma basate su Amazon Linux AMI AL1 () come ritirato.** Per ulteriori informazioni sulla migrazione a una ramificazione della piattaforma Amazon Linux 2023 attuale e completamente supportata, consulta [Migrazione dell'applicazione Elastic Beanstalk Linux ad Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).

### Passaggio delle porte — Amazon Linux AMI (AL1)
<a name="java-se-procfile.alami.ports"></a>

Per impostazione predefinita, Elastic Beanstalk configura il proxy nginx per inoltrare le richieste alla tua applicazione sulla porta 5000. È possibile sostituire la porta predefinita impostando la [proprietà dell'ambiente](java-se-platform.md#java-se-options) `PORT` sulla porta di ascolto dell'applicazione principale.

Se utilizzi un `Procfile` per eseguire più applicazioni, Elastic Beanstalk sulle versioni della piattaforma AMI Amazon Linux si aspetta che ogni applicazione aggiuntiva ascolti su una porta superiore di 100 rispetto alla precedente. Elastic Beanstalk imposta la variabile PORT accessibile all'interno di ogni applicazione per la porta su cui si aspetta venga eseguita l'applicazione. È possibile accedere a questa variabile all'interno dell'applicazione chiamando `System.getenv("PORT")`.

Nell'esempio precedente `Procfile`, l'applicazione `web` è in ascolto sulla porta 5000, `cache` è in ascolto sulla porta 5100 e `web_foo` sulla porta 5200. `web` configura la propria porta di ascolto leggendo la variabile `PORT` e aggiungendo 100 al numero di porta per determinare su quale porta è in ascolto `cache`, in modo che sia possibile inviarvi delle richieste.

# Configurazione del server proxy
<a name="java-se-nginx"></a>

Elastic Beanstalk usa [nginx](https://www.nginx.com/) come proxy inverso per mappare l'applicazione al load balancer Elastic Load Balancing sulla porta 80. Elastic Beanstalk fornisce una configurazione nginx predefinita che puoi estendere o ignorare completamente a favore di quella personalizzata.

Per impostazione predefinita, Elastic Beanstalk configura il proxy nginx per inoltrare le richieste alla tua applicazione sulla porta 5000. È possibile sostituire la porta predefinita impostando la [proprietà dell'ambiente](java-se-platform.md#java-se-options) `PORT` sulla porta di ascolto dell'applicazione principale.

**Nota**  
La porta di ascolto della tua applicazione non influisce sulla porta che il server nginx ascolta per ricevere richieste dal load balancer.

**Configurazione del server proxy sulla versione della piattaforma**  
Tutte le AL2 piattaforme AL2 023/ supportano una funzionalità di configurazione proxy uniforme. Per ulteriori informazioni sulla configurazione del server proxy sulle versioni della piattaforma che eseguono AL2 AL2 023/, consulta. [Configurazione del proxy inverso](platforms-linux-extend.proxy.md) 

## Configurazione del proxy su AMI Amazon Linux (precedente ad Amazon Linux 2)
<a name="java-se-nginx.alami"></a>

Se il tuo ambiente Java SE di Elastic Beanstalk utilizza una versione della piattaforma AMI Amazon Linux (precedente Amazon Linux 2), leggi le informazioni aggiuntive presenti in questa sezione.

**Note**  
Le informazioni contenute in questo argomento si applicano solo ai rami della piattaforma basati su Amazon Linux AMI (AL1). AL2I rami della AL2 piattaforma 023/ non sono compatibili con le versioni precedenti della piattaforma Amazon Linux AMI (AL1) e *richiedono impostazioni di configurazione diverse*.
 [Il 18 luglio 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk ha impostato lo stato di tutte le filiali della piattaforma basate su Amazon Linux AMI AL1 () come ritirato.** Per ulteriori informazioni sulla migrazione a una ramificazione della piattaforma Amazon Linux 2023 attuale e completamente supportata, consulta [Migrazione dell'applicazione Elastic Beanstalk Linux ad Amazon Linux 2023 o Amazon Linux 2](using-features.migration-al.md).

### Estensione e sovrascrittura della configurazione proxy predefinita — Amazon Linux AMI () AL1
<a name="java-se-nginx.alami.extending"></a>

Per estendere la configurazione nginx predefinita di Elastic Beanstalk, aggiungi file di configurazione `.conf` in una cartella denominata `.ebextensions/nginx/conf.d/` nel bundle di origine dell'applicazione. La configurazione nginx di Elastic Beanstalk include automaticamente i file `.conf` in questa cartella.

```
~/workspace/my-app/
|-- .ebextensions
|   `-- nginx
|       `-- conf.d
|           `-- myconf.conf
`-- web.jar
```

Per sostituire completamente la configurazione nginx predefinita di Elastic Beanstalk, includi una configurazione nel bundle di origine in `.ebextensions/nginx/nginx.conf`:

```
~/workspace/my-app/
|-- .ebextensions
|   `-- nginx
|       `-- nginx.conf
`-- web.jar
```

Se ignori la configurazione nginx predefinita di Elastic Beanstalk, aggiungi al file `nginx.conf` la riga seguente per inserire le configurazioni di Elastic Beanstalk per [Reportistica e monitoraggio dello stato di salute migliorati in Elastic Beanstalk](health-enhanced.md), le mappature automatiche delle applicazioni e i file statici.

```
 include conf.d/elasticbeanstalk/*.conf;
```

La seguente configurazione di esempio dall'[applicazione di esempio Scorekeep](https://github.com/aws-samples/eb-java-scorekeep/) sostituisce la configurazione predefinita di Elastic Beanstalk per utilizzare un'applicazione Web statica dalla sottodirectory `public` di `/var/app/current`, in cui la piattaforma Java SE copia il codice sorgente dell'applicazione. La posizione `/api` inoltra il traffico verso i percorsi di `/api/` dell'applicazione Spring sulla porta 5000. Il traffico restante viene distribuito dall'applicazione Web al percorso root.

**Example**  

```
user                    nginx;
error_log               /var/log/nginx/error.log warn;
pid                     /var/run/nginx.pid;
worker_processes        auto;
worker_rlimit_nofile    33282;

events {
    worker_connections  1024;
}

http {
  include       /etc/nginx/mime.types;
  default_type  application/octet-stream;

  log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                    '$status $body_bytes_sent "$http_referer" '
                    '"$http_user_agent" "$http_x_forwarded_for"';

  include       conf.d/*.conf;

  map $http_upgrade $connection_upgrade {
      default     "upgrade";
  }

  server {
      listen        80 default_server;
      root /var/app/current/public;

      location / {
      }git pull
      

      location /api {
          proxy_pass          http://127.0.0.1:5000;
          proxy_http_version  1.1;

          proxy_set_header    Connection          $connection_upgrade;
          proxy_set_header    Upgrade             $http_upgrade;
          proxy_set_header    Host                $host;
          proxy_set_header    X-Real-IP           $remote_addr;
          proxy_set_header    X-Forwarded-For     $proxy_add_x_forwarded_for;
      }

      access_log    /var/log/nginx/access.log main;

      client_header_timeout 60;
      client_body_timeout   60;
      keepalive_timeout     60;
      gzip                  off;
      gzip_comp_level       4;

      # Include the Elastic Beanstalk generated locations
      include conf.d/elasticbeanstalk/01_static.conf;
      include conf.d/elasticbeanstalk/healthd.conf;
  }
}
```

# Aggiungere un'istanza Amazon RDS DB all'ambiente Java Elastic Beanstalk
<a name="java-rds"></a>

Questo argomento fornisce istruzioni per creare un Amazon RDS utilizzando la console Elastic Beanstalk. Puoi utilizzare un'istanza database Amazon Relational Database Service (Amazon RDS) per archiviare i dati raccolti e modificati dall'applicazione. Il database può essere collegato all'ambiente e gestito da Elastic Beanstalk oppure può essere creato e gestito esternamente.

Se utilizzi Amazon RDS per la prima volta, aggiungi un'istanza database in un ambiente di test con la console Elastic Beanstalk e verifica che la tua applicazione sia in grado di connettersi a essa. 

**Per aggiungere un'istanza database al tuo ambiente**

1. Apri la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) e, **nell'elenco Regioni, seleziona la tua**. Regione AWS

1. Nel pannello di navigazione selezionare **Environments** (Ambienti), quindi selezionare il nome dell'ambiente dall'elenco.

1. Nel pannello di navigazione, selezionare **Configuration** (Configurazione).

1. Nella categoria di configurazione del **Database**, scegliere **Edit (Modifica)**.

1. Scegliere un motore di database e immettere un nome utente e una password.

1. Per salvare le modifiche scegli **Apply** (Applica) nella parte inferiore della pagina.

L'aggiunta di un'istanza database richiede circa 10 minuti. Quando l'aggiornamento dell'ambiente è completo, il nome host dell'istanza database e altre informazioni di connessione sono disponibili per la tua applicazione tramite le seguenti proprietà dell'ambiente:


| Nome proprietà | Descrizione | Valore proprietà | 
| --- | --- | --- | 
|  `RDS_HOSTNAME`  |  Il nome host dell'istanza DB.  |  Nella scheda **Connectivity & security** (Connettività e sicurezza) della console Amazon RDS: **Endpoint**.  | 
|  `RDS_PORT`  |  La porta su cui l'istanza database accetta le connessioni. Il valore predefinito varia tra i motori di database.  |  Nella scheda **Connectivity & security (Connettività e sicurezza)** della console Amazon RDS: **Port (Porta)**.  | 
|  `RDS_DB_NAME`  |  Il nome del database, **ebdb**.  |  Nella scheda **Configuration (Configurazione)** della console Amazon RDS: **DB Name (Nome DB)**.  | 
|  `RDS_USERNAME`  |  Il nome utente configurato per il database.  |  Nella scheda **Configuration (Configurazione)** della console Amazon RDS: **Master username (Nome utente master)**.  | 
|  `RDS_PASSWORD`  |  La password configurata per il database.  |  Non disponibile per riferimento nella console Amazon RDS.  | 

Per ulteriori informazioni sulla configurazione di una istanza database interna, consulta [Aggiunta di un database all'ambiente Elastic Beanstalk](using-features.managing.db.md). Per istruzioni su come configurare un database esterno per l'uso con Elastic Beanstalk, consulta [Utilizzo di Elastic Beanstalk con Amazon RDS](AWSHowTo.RDS.md).

Per connetterti al database, aggiungi il file JAR driver appropriato all'applicazione, carica la classe del driver nel codice e crea un oggetto di connessione con le proprietà dell'ambiente fornite da Elastic Beanstalk.

**Topics**
+ [

## Download del driver JDBC
](#java-rds-drivers)
+ [

## Connessione a un database (piattaforme Java SE)
](#java-rds-javase)
+ [

## Connessione a un database (piattaforme Tomcat)
](#java-rds-tomcat)
+ [

## Risoluzione dei problemi di connessione del database
](#create_deploy_Java.rds.troubleshooting)

## Download del driver JDBC
<a name="java-rds-drivers"></a>

Avrai bisogno del file JAR del driver JDBC per il motore di database scelto. Salva il file JAR nel tuo codice sorgente e includilo nel tuo classpath quando compili la classe che crea le connessioni al database.

Puoi trovare il driver più recente per il motore di database nelle seguenti posizioni:
+ **MySQL** - [MySQL Connector/J](https://dev.mysql.com/downloads/connector/j/)
+ **Oracle SE-1** - [Oracle JDBC Driver](http://www.oracle.com/technetwork/database/features/jdbc/index-091264.html)
+ **Postgres** - [PostgreSQL JDBC Driver](https://jdbc.postgresql.org/)
+ **SQL Server** - [Microsoft JDBC Driver](https://msdn.microsoft.com/en-us/sqlserver/aa937724.aspx)

Per usare il driver JDBC, effettuare la chiamata a `Class.forName()` per caricarlo prima di creare la connessione con `DriverManager.getConnection()` nel codice.

JDBC utilizza una stringa di connessione nel formato seguente:

```
jdbc:driver://hostname:port/dbName?user=userName&password=password
```

Puoi recuperare il nome host, la porta, il nome del database, il nome utente e la password dalle variabili di ambiente che Elastic Beanstalk fornisce alla tua applicazione. Il nome del driver è specifico per il tuo tipo di database e per la versione del driver. Di seguito vengono riportati esempi di nomi di driver:
+ `mysql` per MySQL
+ `postgresql` per PostgreSQL
+ `oracle:thin` per Oracle Thin
+ `oracle:oci` per Oracle OCI
+ `oracle:oci8` per Oracle OCI 8
+ `oracle:kprb` per Oracle KPRB
+ `sqlserver` per SQL Server

## Connessione a un database (piattaforme Java SE)
<a name="java-rds-javase"></a>

In un ambiente Java SE, utilizza `System.getenv()` per leggere le variabili di connessione dall'ambiente. Il seguente codice di esempio mostra una classe che crea una connessione a un database PostgreSQL.

```
private static Connection getRemoteConnection() {
    if (System.getenv("RDS_HOSTNAME") != null) {
      try {
      Class.forName("org.postgresql.Driver");
      String dbName = System.getenv("RDS_DB_NAME");
      String userName = System.getenv("RDS_USERNAME");
      String password = System.getenv("RDS_PASSWORD");
      String hostname = System.getenv("RDS_HOSTNAME");
      String port = System.getenv("RDS_PORT");
      String jdbcUrl = "jdbc:postgresql://" + hostname + ":" + port + "/" + dbName + "?user=" + userName + "&password=" + password;
      logger.trace("Getting remote connection with connection string from environment variables.");
      Connection con = DriverManager.getConnection(jdbcUrl);
      logger.info("Remote connection successful.");
      return con;
    }
    catch (ClassNotFoundException e) { logger.warn(e.toString());}
    catch (SQLException e) { logger.warn(e.toString());}
    }
    return null;
  }
```

## Connessione a un database (piattaforme Tomcat)
<a name="java-rds-tomcat"></a>

In un ambiente Tomcat, le proprietà dell'ambiente vengono fornite come proprietà di sistema accessibili con `System.getProperty()`.

Il seguente codice di esempio mostra una classe che crea una connessione a un database PostgreSQL.

```
private static Connection getRemoteConnection() {
    if (System.getProperty("RDS_HOSTNAME") != null) {
      try {
      Class.forName("org.postgresql.Driver");
      String dbName = System.getProperty("RDS_DB_NAME");
      String userName = System.getProperty("RDS_USERNAME");
      String password = System.getProperty("RDS_PASSWORD");
      String hostname = System.getProperty("RDS_HOSTNAME");
      String port = System.getProperty("RDS_PORT");
      String jdbcUrl = "jdbc:postgresql://" + hostname + ":" + port + "/" + dbName + "?user=" + userName + "&password=" + password;
      logger.trace("Getting remote connection with connection string from environment variables.");
      Connection con = DriverManager.getConnection(jdbcUrl);
      logger.info("Remote connection successful.");
      return con;
    }
    catch (ClassNotFoundException e) { logger.warn(e.toString());}
    catch (SQLException e) { logger.warn(e.toString());}
    }
    return null;
  }
```

In caso di problemi di connessione o di esecuzione di istruzioni SQL, prova a inserire il codice seguente in un file JSP. Questo codice si connette a un'istanza database, crea una tabella e scrive su di essa.

```
<%@ page import="java.sql.*" %>
<%
  // Read RDS connection information from the environment
  String dbName = System.getProperty("RDS_DB_NAME");
  String userName = System.getProperty("RDS_USERNAME");
  String password = System.getProperty("RDS_PASSWORD");
  String hostname = System.getProperty("RDS_HOSTNAME");
  String port = System.getProperty("RDS_PORT");
  String jdbcUrl = "jdbc:mysql://" + hostname + ":" +
    port + "/" + dbName + "?user=" + userName + "&password=" + password;
  
  // Load the JDBC driver
  try {
    System.out.println("Loading driver...");
    Class.forName("com.mysql.jdbc.Driver");
    System.out.println("Driver loaded!");
  } catch (ClassNotFoundException e) {
    throw new RuntimeException("Cannot find the driver in the classpath!", e);
  }

  Connection conn = null;
  Statement setupStatement = null;
  Statement readStatement = null;
  ResultSet resultSet = null;
  String results = "";
  int numresults = 0;
  String statement = null;

  try {
    // Create connection to RDS DB instance
    conn = DriverManager.getConnection(jdbcUrl);
    
    // Create a table and write two rows
    setupStatement = conn.createStatement();
    String createTable = "CREATE TABLE Beanstalk (Resource char(50));";
    String insertRow1 = "INSERT INTO Beanstalk (Resource) VALUES ('EC2 Instance');";
    String insertRow2 = "INSERT INTO Beanstalk (Resource) VALUES ('RDS Instance');";
    
    setupStatement.addBatch(createTable);
    setupStatement.addBatch(insertRow1);
    setupStatement.addBatch(insertRow2);
    setupStatement.executeBatch();
    setupStatement.close();
    
  } catch (SQLException ex) {
    // Handle any errors
    System.out.println("SQLException: " + ex.getMessage());
    System.out.println("SQLState: " + ex.getSQLState());
    System.out.println("VendorError: " + ex.getErrorCode());
  } finally {
    System.out.println("Closing the connection.");
    if (conn != null) try { conn.close(); } catch (SQLException ignore) {}
  }

  try {
    conn = DriverManager.getConnection(jdbcUrl);
    
    readStatement = conn.createStatement();
    resultSet = readStatement.executeQuery("SELECT Resource FROM Beanstalk;");

    resultSet.first();
    results = resultSet.getString("Resource");
    resultSet.next();
    results += ", " + resultSet.getString("Resource");
    
    resultSet.close();
    readStatement.close();
    conn.close();

  } catch (SQLException ex) {
    // Handle any errors
    System.out.println("SQLException: " + ex.getMessage());
    System.out.println("SQLState: " + ex.getSQLState());
    System.out.println("VendorError: " + ex.getErrorCode());
  } finally {
       System.out.println("Closing the connection.");
      if (conn != null) try { conn.close(); } catch (SQLException ignore) {}
  }
%>
```

Per visualizzare i risultati, inserisci il codice seguente nel corpo della porzione HTML del file JSP.

```
<p>Established connection to RDS. Read first two rows: <%= results %></p>
```

## Risoluzione dei problemi di connessione del database
<a name="create_deploy_Java.rds.troubleshooting"></a>

**Prova Amazon Q Developer CLI per la risoluzione dei problemi assistita dall'intelligenza artificiale**  
 La CLI per sviluppatori di Amazon Q può aiutarti a risolvere rapidamente i problemi ambientali. La Q CLI fornisce soluzioni controllando lo stato dell'ambiente, esaminando gli eventi, analizzando i log e ponendo domande di chiarimento. Per ulteriori informazioni e procedure dettagliate, consulta Risoluzione dei problemi degli [ambienti Elastic Beanstalk con Amazon](https://aws.amazon.com/blogs/devops/troubleshooting-elastic-beanstalk-environments-with-amazon-q-developer-cli/) Q Developer CLI nei blog. AWS 

In caso di problemi di connessione a un database all'interno dell'applicazione, rivedi il log del container Web e il database.

### Revisione dei log
<a name="create_deploy_Java.rds.troubleshooting.logs"></a>

Puoi visualizzare tutti i log dall'ambiente Elastic Beanstalk all'interno di Eclipse. **Se non hai la vista AWS Explorer aperta, scegli la freccia accanto all' AWS icona arancione nella barra degli strumenti, quindi scegli Mostra visualizzazione Explorer. AWS ** Espandi **AWS Elastic Beanstalk** e il nome dell'ambiente, quindi apri il menu contestuale (pulsante destro del mouse) per il server. Seleziona **Open in WTP Server Editor (Apri in WTP Server Editor)**. 

 Scegli la scheda **Log** della vista del **Server** per visualizzare i log di aggregazione dell'ambiente. Per aprire gli ultimi log, scegli il pulsante **Refresh (Aggiorna)** nell'angolo in alto a destra della pagina. 

 Scendi verso il basso per individuare i log Tomcat in `/var/log/tomcat7/catalina.out`. Se hai caricato la pagina Web dal nostro esempio precedente più volte, potresti visualizzare quanto segue. 

```
-------------------------------------
/var/log/tomcat7/catalina.out
-------------------------------------
INFO: Server startup in 9285 ms
Loading driver...
Driver loaded!
SQLException: Table 'Beanstalk' already exists
SQLState: 42S01
VendorError: 1050
Closing the connection.
Closing the connection.
```

Tutte le informazioni che l'applicazione Web invia all'output standard appaiono nel log del container Web. Nell'esempio precedente, l'applicazione cerca di creare la tabella ogni volta che la pagina viene caricata. Questo determina un'eccezione SQL su tutte le pagine caricate dopo la prima. 

Ad esempio, l'operazione precedente è accettabile. Tuttavia, nelle applicazioni concrete, mantieni le definizioni del tuo database in oggetti dello schema, esegui le transazioni all'interno di classi di modelli e coordina le richieste con servlet di controller.

### Connessione all'istanza database RDS
<a name="create_deploy_Java.rds.troubleshooting.connecting"></a>

 Puoi connetterti direttamente all'istanza database RDS all'interno dell'ambiente Elastic Beanstalk utilizzando l'applicazione client MySQL. 

 In primo luogo, apri il gruppo di sicurezza all'istanza database di RDS per consentire il traffico dal tuo computer. 

1. Apri la console [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) e, **nell'elenco Regioni, seleziona la tua**. Regione AWS

1. Nel pannello di navigazione selezionare **Environments** (Ambienti), quindi selezionare il nome dell'ambiente dall'elenco.

1. Nel pannello di navigazione, selezionare **Configuration** (Configurazione).

1. Nella categoria di configurazione del **Database**, scegliere **Edit (Modifica)**.

1. Accanto a **Endpoint**, scegli il collegamento della console Amazon RDS.

1. Nella pagina dei dettagli dell'istanza **RDS Dashboard (Pannello di controllo RDS)** in **Security and Network (Sicurezza e rete)**, seleziona il gruppo di sicurezza che inizia con *rds-* accanto a **Security Groups (Gruppi di sicurezza)**.
**Nota**  
Il database potrebbe avere più voci etichettate con **Security Groups(Gruppi di sicurezza)**. Utilizza il primo che inizia con *awseb*, solo se hai un account precedente che non dispone di un [Amazon Virtual Private Cloud](https://docs.aws.amazon.com/vpc/latest/userguide/) (Amazon VPC) predefinito.

1. In **Security group details (Dettagli gruppi di sicurezza)**, seleziona la scheda **Inbound (In ingresso)**, quindi **Edit (Modifica)**.

1. Aggiungi una regola per MySQL (porta 3306) che consente il traffico dal tuo indirizzo IP, specificato nel formato CIDR.

1. Scegliere **Save (Salva)**. Le modifiche diventano effettive immediatamente.

 Torna ai dettagli di configurazione di Elastic Beanstalk per l'ambiente e prendi nota dell'endpoint. Puoi utilizzare il nome di dominio per la connessione all'istanza database di RDS. 

 Installa il client MySQL e avvia una connessione al database sulla porta 3306. In Windows, installa MySQL Workbench dalla home page di MySQL e segui le istruzioni. 

 Su Linux, installa il client MySQL utilizzando il programma di gestione dei pacchetti per la tua distribuzione. L'esempio seguente funziona con Ubuntu e altri derivati Debian. 

```
// Install MySQL client
$ sudo apt-get install mysql-client-5.5
...
// Connect to database
$ mysql -h aas839jo2vwhwb.cnubrrfwfka8.us-west-2.rds.amazonaws.com -u username -ppassword ebdb
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 117
Server version: 5.5.40-log Source distribution
...
```

Dopo aver effettuato la connessione, è possibile eseguire comandi SQL per visualizzare lo stato del database, se le tabelle e le righe sono state create e altre informazioni. 

```
mysql> SELECT Resource from Beanstalk;
+--------------+
| Resource     |
+--------------+
| EC2 Instance |
| RDS Instance |
+--------------+
2 rows in set (0.01 sec)
```

# Strumenti e risorse Java
<a name="create_deploy_Java.resources"></a>

Puoi trovare informazioni utili per lo sviluppo delle applicazioni Java in diverse posizioni:


****  

|  Risorsa  |  Description  | 
| --- | --- | 
|  [Il forum di sviluppo AWS Java](https://forums.aws.amazon.com/forum.jspa?forumID=70)  | Pubblica le tue domande e ricevi un feedback.  | 
|  [Centro sviluppatori Java](https://aws.amazon.com/java/)  | Punto di riferimento per il codice di esempio, la documentazione, gli strumenti e risorse aggiuntive. |