AWS Cloud9 non è più disponibile per i nuovi clienti. I clienti esistenti di AWS Cloud9 possono continuare a utilizzare il servizio come di consueto. [Ulteriori informazioni](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/) 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à. # Tutorial Java per AWS Cloud9 **Importante** Se utilizzi un ambiente di AWS Cloud9 sviluppo supportato da un'istanza EC2 con 2 GiB o più di memoria, ti consigliamo di attivare il supporto Java avanzato. Ciò consente di accedere a caratteristiche di produttività come il completamento del codice, l'analisi del codice con segnalazione degli errori, le operazioni specifiche per il contesto e le opzioni di debug, come i punti di interruzione e le suddivisioni in fasi. Per ulteriori informazioni, consulta [Supporto avanzato per lo sviluppo Java](enhanced-java.md). Questo tutorial ti consente di eseguire del codice Java in un ambiente di AWS Cloud9 sviluppo. L'esecuzione di questo tutorial e la creazione di questo esempio potrebbero comportare addebiti sul tuo AWS account. Questi includono possibili addebiti per servizi come Amazon EC2 e Amazon S3. Per ulteriori informazioni, consulta [Prezzi di Amazon EC2](https://aws.amazon.com/ec2/pricing/) e [Prezzi di Amazon S3](https://aws.amazon.com/s3/pricing/). **Topics** + [Prerequisiti](#sample-java-prerequisites) + [Fase 1: installare gli strumenti necessari](#sample-java-install) + [Fase 2: aggiungere un codice](#sample-java-code) + [Fase 3: costruire ed eseguire il codice](#sample-java-run) + [Passaggio 4: Configurazione per l'utilizzo di AWS SDK per Java](#sample-java-sdk) + [Fase 5: Configurare la gestione AWS delle credenziali nel proprio ambiente](#sample-java-sdk-creds) + [Passaggio 6: Aggiungere AWS il codice SDK](#sample-java-sdk-code) + [Passaggio 7: Crea ed esegui il codice AWS SDK](#sample-java-sdk-run) + [Fase 8: Pulizia](#sample-java-clean-up) ## Prerequisiti Prima di usare questo esempio, assicurati che la configurazione soddisfi i seguenti requisiti: + **È necessario disporre di un ambiente di sviluppo AWS Cloud9 EC2 esistente.** Nell'esempio si presume che tu disponga già di un ambiente EC2 connesso a un'istanza Amazon EC2 in cui viene eseguito Amazon Linux o Ubuntu Server. Se disponi di un altro tipo di ambiente o sistema operativo, potrebbe essere necessario adattare le istruzioni di questo esempio per configurare gli strumenti correlati. Per ulteriori informazioni, consulta [Creare un ambiente in AWS Cloud9](create-environment.md). + **L' AWS Cloud9 IDE per l'ambiente esistente è già aperto.** Quando apri un ambiente, AWS Cloud9 apre l'IDE per quell'ambiente nel tuo browser web. Per ulteriori informazioni, consulta [Aprire un ambiente in AWS Cloud9](open-environment.md). ## Fase 1: installare gli strumenti necessari In questa fase, installate un set di strumenti di sviluppo Java nel vostro ambiente di AWS Cloud9 sviluppo. Se nell'ambiente è già installato un set di strumenti di sviluppo Java, come Oracle JDK o OpenJDK, puoi passare a [Fase 2: aggiungere un codice](#sample-java-code). Questo esempio è stato sviluppato con OpenJDK 8, che puoi installare nell'ambiente completando la procedura seguente. 1. Conferma se OpenJDK 8 è già installato. Per fare ciò, in una sessione terminale nell' AWS Cloud9 IDE, esegui la versione a riga di comando di Java runner con l'**`-version`**opzione. Per avviare una nuova sessione del terminale, dalla barra dei menu scegli **Window** (Finestra), **New Terminal** (Nuovo terminale). ``` java -version ``` Dipendentemente dall'output del comando precedente, effettua una delle opzioni seguenti: + Se l'output indica che il comando `java` non viene trovato, continua con la fase 2 di questa procedura per installare OpenJDK 8. + Se l'output contiene valori che iniziano con `Java(TM)`, `Java Runtime Environment`, `Java SE`, `J2SE` o `Java2`, OpenJDK non è installato o non è impostato come set di strumenti di sviluppo Java predefinito. Continua con la fase 2 di questa procedura per installare OpenJDK 8, quindi passa all'utilizzo di OpenJDK 8. + Se l'output contiene valori che iniziano con `java version 1.8` e `OpenJDK`, passa a [Fase 2: aggiungere un codice](#sample-java-code). OpenJDK 8 è installato correttamente per questo esempio. + Se l'output contiene una `java version` inferiore a `1.8` e valori che iniziano con `OpenJDK`, continua con la fase 2 di questa procedura per aggiornare la versione di OpenJDK a OpenJDK 8. 1. Assicurati che siano installati gli aggiornamenti di sicurezza e le correzioni dei bug i più recenti. Per effettuare questa operazione, esegui lo strumento yum (per Amazon Linux) o apt (per Ubuntu Server) con il comando ** `update` **. Per Amazon Linux: ``` sudo yum -y update ``` Per Ubuntu Server: ``` sudo apt update ``` 1. Installa OpenJDK 8. Per effettuare questa operazione, esegui lo strumento yum (per Amazon Linux) o apt (per Ubuntu Server) con il comando ** `install` **, specificando il pacchetto OpenJDK 8. Per Amazon Linux: ``` sudo yum -y install java-1.8.0-openjdk-devel ``` Per Ubuntu Server: ``` sudo apt install -y openjdk-8-jdk ``` Per ulteriori informazioni, consulta [How to download and install prebuilt OpenJDK packages](https://openjdk.org/install/) sul sito Web di OpenJDK. 1. Passa o aggiorna il set di strumenti di sviluppo Java predefinito a OpenJDK 8. A tale scopo, eseguire il comando ** `update-alternatives` ** con l'opzione ** `--config` **. Esegui il comando due volte per passare o aggiornare le versioni della riga di comando del runner e compilatore Java. ``` sudo update-alternatives --config java sudo update-alternatives --config javac ``` A ogni prompt digita il numero di selezione per OpenJDK 8 (quello che contiene `java-1.8`). 1. Verifica che le versioni della riga di comando del runner e compilatore Java utilizzino OpenJDK 8. Per effettuare questa operazione, esegui le versioni della riga di comando del runner e compilatore Java con l'opzione `-version`. ``` java -version javac -version ``` Se OpenJDK 8 è installato e impostato correttamente, l'output della versione del runner Java contiene un valore che inizia con `openjdk version 1.8` e l'output della versione del compilatore Java inizia con il valore `javac 1.8`. ## Fase 2: aggiungere un codice Nell' AWS Cloud9 IDE, create un file con il codice seguente e salvate il file con il nome`hello.java`. (Per creare un file, nella barra dei menu scegli **File**, **New File** (Nuovo file). Per salvare il file, scegli **File**,**Save** (Salva)). ``` public class hello { public static void main(String []args) { System.out.println("Hello, World!"); System.out.println("The sum of 2 and 3 is 5."); int sum = Integer.parseInt(args[0]) + Integer.parseInt(args[1]); System.out.format("The sum of %s and %s is %s.\n", args[0], args[1], Integer.toString(sum)); } } ``` ## Fase 3: costruire ed eseguire il codice 1. Utilizza la versione della riga di comando del compilatore Java per compilare il file `hello.java` in un file `hello.class`. Per fare ciò, utilizzando il terminale nell' AWS Cloud9 IDE, dalla stessa directory del `hello.java` file, esegui il compilatore Java, specificando il `hello.java` file. ``` javac hello.java ``` 1. Utilizza la versione della riga di comando del runner Java per eseguire il file `hello.class`. Per effettuare questa operazione, dalla stessa directory del file `hello.class`, esegui il runner Java, specificando il nome della classe `hello` che è stata dichiarata nel file `hello.java`, con due numeri interi da aggiungere (ad esempio, `5` e `9`). ``` java hello 5 9 ``` 1. Confronta i risultati. ``` Hello, World! The sum of 2 and 3 is 5. The sum of 5 and 9 is 14. ``` ## Passaggio 4: Configurazione per l'utilizzo di AWS SDK per Java Puoi migliorare questo esempio per utilizzare il bucket Amazon S3, AWS SDK per Java elencare i bucket disponibili e quindi eliminare il bucket appena creato. In questa fase si installa [Apache Maven](https://maven.apache.org/) o [Gradle](https://gradle.org/) nell'ambiente. Maven e Gradle sono sistemi di automazione di compilazione comuni che possono essere usati con progetti Java. Dopo aver installato Maven o Gradle, è possibile usarlo per generare un nuovo progetto Java. In questo nuovo progetto, aggiungi un riferimento ad AWS SDK per Java. Ciò AWS SDK per Java fornisce un modo conveniente per interagire con AWS servizi come Amazon S3, dal tuo codice Java. **Topics** + [Configurazione con Maven](#sample-java-sdk-maven) + [Configurazione con Gradle](#sample-java-sdk-gradle) ### Configurazione con Maven 1. Installa Maven nell'ambiente. Per vedere se Maven è già installato, usando il terminale nell' AWS Cloud9 IDE, esegui Maven con l'opzione. **`-version`** ``` mvn -version ``` In caso di esito positivo, l'output includerà il numero di versione di Maven. Se Maven è già installato, passa alla fase 4 in questa procedura per utilizzare Maven per generare un nuovo progetto Java nell'ambiente. 1. Installa Maven utilizzando il terminale per eseguire i seguenti comandi. Per Amazon Linux, i seguenti comandi ottengono informazioni sul repository di pacchetti in cui è archiviato Maven, quindi utilizzano queste informazioni per installare Maven. ``` sudo wget http://repos.fedorapeople.org/repos/dchen/apache-maven/epel-apache-maven.repo -O /etc/yum.repos.d/epel-apache-maven.repo sudo sed -i s/\$releasever/6/g /etc/yum.repos.d/epel-apache-maven.repo sudo yum install -y apache-maven ``` Per ulteriori informazioni sui comandi precedenti, consulta [Extra Packages for Enterprise Linux (EPEL)](https://docs.fedoraproject.org/en-US/epel/) sul sito Web Fedora Project Wiki. Per Ubuntu Server, esegui invece il comando seguente. ``` sudo apt install -y maven ``` 1. Conferma l'installazione eseguendo Maven con l'opzione ** `-version` **. ``` mvn -version ``` 1. Utilizza Maven per generare un nuovo progetto Java. Per effettuare questa operazione, utilizza il terminale per eseguire il comando seguente dalla directory in cui Maven deve generare il progetto (ad esempio, la directory principale dell'ambiente). ``` mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false ``` Il comando precedente crea la seguente struttura di directory per il progetto nell'ambiente. ``` my-app |- src | `- main | `- java | `- com | `- mycompany | `- app | `-App.java |- test | `- java | `- com | `- mycompany | `- app | `- AppTest.java `- pom.xml ``` Per ulteriori informazioni sulla struttura di directory precedente, consulta [Maven Quickstart Archetype](https://maven.apache.org/archetypes/maven-archetype-quickstart/) e [Introduction to the Standard Directory Layout](https://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html) sul sito Web Apache Maven Project. 1. Modifica il file Project Object Model (POM) per il progetto. Un file POM definisce le impostazioni di un progetto Maven. Per effettuare questa operazione, dalla finestra **Environment (Ambiente)** apri il file `my-app/pom.xml`. Nell'editor sostituisci i contenuti del file con il seguente codice e salva il file `pom.xml`. ``` 4.0.0 com.mycompany.app my-app jar 1.0-SNAPSHOT org.apache.maven.plugins maven-assembly-plugin 3.6.0 jar-with-dependencies com.mycompany.app.App package single junit junit 3.8.1 test com.amazonaws aws-java-sdk 1.11.330 ``` Il file POM precedente include le impostazioni di progetto che specificano dichiarazioni come le seguenti: + L'impostazione `artifactid` di `my-app` imposta il nome della directory principale del progetto, mentre l'impostazione `group-id` di `com.mycompany.app` imposta la struttura di sottodirectory `com/mycompany/app` e la dichiarazione `package` nei file `App.Java` e `AppTest.java`. + L'impostazione `artifactId` di `my-app`, con l'impostazione `packaging` di `jar`, l'impostazione `version` di `1.0-SNAPSHOT` e l'impostazione `descriptorRef` di `jar-with-dependencies` impostano il nome del file JAR di output di `my-app-1.0-SNAPSHOT-jar-with-dependencies.jar`. + La sezione `plugin` dichiara che verrà creato un singolo JAR, che include tutte le dipendenze. + La `dependency` sezione con l'`groupId`impostazione `com.amazon.aws` e l'impostazione di `aws-java-sdk` include i `artifactId` file della libreria. AWS SDK per Java La versione dell' AWS SDK per Java da utilizzare è indicata nell'impostazione `version`. Per usare una versione diversa, sostituire questo numero di versione. Passare direttamente a [Fase 5: Configurare la gestione AWS delle credenziali nel proprio ambiente](#sample-java-sdk-creds). ### Configurazione con Gradle 1. Installa Gradle nell'ambiente. Per vedere se Gradle è già installato, usando il terminale nell' AWS Cloud9 IDE, esegui Gradle con l'**`-version`**opzione. ``` gradle -version ``` In caso di esito positivo, l'output includerà il numero di versione di Gradle. Se Gradle è già installato, passa alla fase 4 in questa procedura per utilizzare Gradle per generare un nuovo progetto Java nell'ambiente. 1. Installa Gradle utilizzando il terminale per eseguire i seguenti comandi. Questi comandi consentono di installare ed eseguire lo strumento SDKMAN\$1 e di utilizzare quindi SDKMAN\$1 per installare la versione più recente di Gradle. ``` curl -s "https://get.sdkman.io" | bash source "$HOME/.sdkman/bin/sdkman-init.sh" sdk install gradle ``` Per ulteriori informazioni sui comandi precedenti, consulta [Installation](https://sdkman.io/install) sul sito Web SDKMAN\$1 e [Install with a package manager](https://gradle.org/install/#with-a-package-manager) sul sito Web Gradle. 1. Conferma l'installazione eseguendo Gradle con l'opzione ** `-version` **. ``` gradle -version ``` 1. Usa Gradle per generare un nuovo progetto Java nell'ambiente. Per effettuare questa operazione, usa il terminale per eseguire i seguenti comandi per creare una directory per il progetto, quindi passa a quella directory. ``` mkdir my-app cd my-app ``` 1. Esegui il comando seguente per fare in modo che Gradle generi un nuovo progetto di applicazione Java nella directory `my-app` dell'ambiente. ``` gradle init --type java-application ``` Il comando precedente crea la seguente struttura di directory per il progetto nell'ambiente. ``` my-app |- .gradle | `- (various supporting project folders and files) |- gradle | `- (various supporting project folders and files) |- src | |- main | | `- java | | `- App.java | `- test | `- java | `- AppTest.java |- build.gradle |- gradlew |- gradlew.bat `- settings.gradle ``` 1. Modifica `AppTest.java` per il progetto. Se non si effettua questa operazione, il progetto potrebbe non essere creato o eseguito come previsto. Per effettuare questa operazione, dalla finestra **Environment (Ambiente)** apri il file `my-app/src/test/java/AppTest.java`. Nell'editor sostituisci i contenuti del file con il seguente codice e salva il file `AppTest.java`. ``` import org.junit.Test; import static org.junit.Assert.*; public class AppTest { @Test public void testAppExists () { try { Class.forName("com.mycompany.app.App"); } catch (ClassNotFoundException e) { fail("Should have a class named App."); } } } ``` 1. Modifica il file `build.gradle` per il progetto. Un file `build.gradle` definisce le impostazioni di un progetto Gradle. Per effettuare questa operazione, dalla finestra **Environment (Ambiente)** apri il file `my-app/build.gradle`. Nell'editor sostituisci i contenuti del file con il seguente codice e salva il file `build.gradle`. ``` apply plugin: 'java' apply plugin: 'application' repositories { jcenter() mavenCentral() } buildscript { repositories { mavenCentral() } dependencies { classpath "io.spring.gradle:dependency-management-plugin:1.0.3.RELEASE" } } apply plugin: "io.spring.dependency-management" dependencyManagement { imports { mavenBom 'com.amazonaws:aws-java-sdk-bom:1.11.330' } } dependencies { compile 'com.amazonaws:aws-java-sdk-s3' testCompile group: 'junit', name: 'junit', version: '4.12' } run { if (project.hasProperty("appArgs")) { args Eval.me(appArgs) } } mainClassName = 'App' ``` Il file `build.gradle` precedente include le impostazioni di progetto che specificano dichiarazioni come le seguenti: + Il `io.spring.dependency-management` plugin viene utilizzato per importare la AWS SDK per Java Maven Bill of Materials (BOM) per gestire le AWS SDK per Java dipendenze del progetto. `classpath`dichiara la versione da usare. Per usare una versione diversa, sostituire questo numero di versione. + `com.amazonaws:aws-java-sdk-s3` include la porzione di Amazon S3 dei file libreria dell' AWS SDK per Java . `mavenBom` indica la versione da utilizzare. Per usare una versione diversa, sostituire questo numero di versione. ## Fase 5: Configurare la gestione AWS delle credenziali nel proprio ambiente Ogni volta che si utilizza il AWS SDK per Java per chiamare un AWS servizio, è necessario fornire un set di AWS credenziali con la chiamata. Queste credenziali determinano se AWS SDK per Java dispone delle autorizzazioni appropriate per effettuare quella chiamata. Se le credenziali non coprono le autorizzazioni appropriate, la chiamata fallirà. In questa fase si archiviano le credenziali all'interno dell'ambiente A questo proposito, segui le istruzioni riportate in [Chiamata Servizi AWS da un ambiente in AWS Cloud9](credentials.md), quindi torna a questo argomento. Per ulteriori informazioni, consulta [Configurazione delle credenziali e della regione AWS per lo sviluppo](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html#setup-credentials) nella *Guida per gli sviluppatori di AWS SDK per Java *. ## Passaggio 6: Aggiungere AWS il codice SDK In questa fase si aggiungi codice per interagire con Amazon S3 e creare un bucket, elencare i bucket disponibili ed eliminare il bucket appena creato. Dalla finestra **Environment (Ambiente)** aprire il file `my-app/src/main/java/com/mycompany/app/App.java` per Maven o il file `my-app/src/main/java/App.java` per Gradle. Nell'editor sostituisci i contenuti del file con il seguente codice e salva il file `App.java`. ``` package com.mycompany.app; import com.amazonaws.auth.profile.ProfileCredentialsProvider; import com.amazonaws.services.s3.AmazonS3; import com.amazonaws.services.s3.AmazonS3ClientBuilder; import com.amazonaws.services.s3.model.AmazonS3Exception; import com.amazonaws.services.s3.model.Bucket; import com.amazonaws.services.s3.model.CreateBucketRequest; import java.util.List; public class App { private static AmazonS3 s3; public static void main(String[] args) { if (args.length < 2) { System.out.format("Usage: \n" + "Example: my-test-bucket us-east-2\n"); return; } String bucket_name = args[0]; String region = args[1]; s3 = AmazonS3ClientBuilder.standard() .withCredentials(new ProfileCredentialsProvider()) .withRegion(region) .build(); // List current buckets. ListMyBuckets(); // Create the bucket. if (s3.doesBucketExistV2(bucket_name)) { System.out.format("\nCannot create the bucket. \n" + "A bucket named '%s' already exists.", bucket_name); return; } else { try { System.out.format("\nCreating a new bucket named '%s'...\n\n", bucket_name); s3.createBucket(new CreateBucketRequest(bucket_name, region)); } catch (AmazonS3Exception e) { System.err.println(e.getErrorMessage()); } } // Confirm that the bucket was created. ListMyBuckets(); // Delete the bucket. try { System.out.format("\nDeleting the bucket named '%s'...\n\n", bucket_name); s3.deleteBucket(bucket_name); } catch (AmazonS3Exception e) { System.err.println(e.getErrorMessage()); } // Confirm that the bucket was deleted. ListMyBuckets(); } private static void ListMyBuckets() { List buckets = s3.listBuckets(); System.out.println("My buckets now are:"); for (Bucket b : buckets) { System.out.println(b.getName()); } } } ``` ## Passaggio 7: Crea ed esegui il codice AWS SDK Per eseguire il codice della fase precedente, esegui i seguenti comandi dal terminale. Questi comandi utilizzano Maven o Gradle per creare un file JAR eseguibile per il progetto e quindi utilizzano il runner Java per eseguire il JAR. Il JAR viene eseguito con il nome del bucket da creare in Amazon S3 (ad esempio`my-test-bucket`) e l'ID della regione in cui creare AWS il bucket come input (ad esempio,). `us-east-2` Per Maven, esegui i comandi riportati di seguito. ``` cd my-app mvn package java -cp target/my-app-1.0-SNAPSHOT-jar-with-dependencies.jar com.mycompany.app.App my-test-bucket us-east-2 ``` Per Gradle, esegui i comandi riportati di seguito. ``` gradle build gradle run -PappArgs="['my-test-bucket', 'us-east-2']" ``` Confronta i tuoi risultati con il seguente output. ``` My buckets now are: Creating a new bucket named 'my-test-bucket'... My buckets now are: my-test-bucket Deleting the bucket named 'my-test-bucket'... My buckets now are: ``` ## Fase 8: Pulizia Per evitare addebiti continui sul tuo AWS account dopo aver utilizzato questo esempio, devi eliminare l'ambiente. Per istruzioni, consulta [Eliminazione di un ambiente in AWS Cloud9](delete-environment.md).