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à. # Guida introduttiva alla versione AWS SDK per Java 2.x Le sezioni di questo argomento illustrano i passaggi essenziali per iniziare a creare applicazioni Java che si connettono a. Servizio AWS Le sezioni riguardano la configurazione dell'ambiente di sviluppo con Java e la creazione di strumenti come Maven o Gradle, la configurazione dell'autenticazione sicura e la creazione della prima applicazione funzionante tramite un tutorial pratico. AWS Questo argomento, adatto ai principianti, funge da punto di partenza per AWS lo sviluppo con Java e fornisce le basi necessarie prima di esplorare funzionalità più avanzate. **Contents** + [Configurazione del AWS SDK per Java 2.x](setup.md) + [Panoramica della configurazione](setup.md#setup-overview) + [Installa Java e uno strumento di compilazione per lavorare con AWS SDK for Java 2.x](setup-java-buildtool.md) + [Configura un progetto Apache Maven che utilizza AWS SDK for Java 2.x](setup-project-maven.md) + [Prerequisiti](setup-project-maven.md#prerequisitesmaven) + [Creare un progetto Maven](setup-project-maven.md#create-maven-project) + [Configurare il compilatore Java per Maven](setup-project-maven.md#configure-maven-compiler) + [Dichiarare l'SDK come dipendenza](setup-project-maven.md#sdk-as-dependency) + [Impostare le dipendenze per i moduli SDK](setup-project-maven.md#modules-dependencies) + [Creare l'intero SDK nel progetto](setup-project-maven.md#build-the-entire-sdk-into-your-project) + [Creare il progetto](setup-project-maven.md#build-project) + [Configura un progetto Gradle che utilizza il AWS SDK for Java 2.x](setup-project-gradle.md) + [Configura un progetto GraalVM Native Image che utilizza AWS SDK for Java 2.x](setup-project-graalvm.md) + [Prerequisiti](setup-project-graalvm.md#setup-graalvmnativeimage-prereq) + [Crea un progetto usando l'archetipo](setup-project-graalvm.md#setup-graalvmnativeimage-project) + [Crea un'immagine nativa](setup-project-graalvm.md#build-graalvmnativeimage-project) + [Autenticazione con l'utilizzo di AWS AWS SDK for Java 2.x](get-started-auth.md) + [Configurazione per l'autenticazione](get-started-auth.md#setup-auth) + [1. Sviluppo locale utilizzando credenziali a breve termine](get-started-auth.md#setup-login) + [2. Configurazione per l'accesso Single Sign-On per l'SDK](get-started-auth.md#setup-credentials) + [3. Effettuate l'accesso utilizzando il AWS CLI](get-started-auth.md#setup-login-sso) + [Opzioni di autenticazione aggiuntive](get-started-auth.md#setup-additional) + [Creazione di una semplice applicazione utilizzando AWS SDK for Java 2.x](get-started-tutorial.md) + [Fase 1: prepararsi per il tutorial](get-started-tutorial.md#get-started-setup) + [Fase 2: creare il progetto](get-started-tutorial.md#get-started-projectsetup) + [Fase 3: scrivere il codice](get-started-tutorial.md#get-started-code) + [Fase 4: creare ed eseguire l’applicazione](get-started-tutorial.md#get-started-run) + [Completato](get-started-tutorial.md#get-started-success) + [Pulizia](get-started-tutorial.md#cleanup) + [Fasi successive](get-started-tutorial.md#get-started-next) # Configurazione del AWS SDK per Java 2.x Questa sezione fornisce informazioni su come configurare l'ambiente di sviluppo e i progetti per l'utilizzo di. AWS SDK for Java 2.x ## Panoramica della configurazione Per sviluppare correttamente applicazioni che accedono Servizi AWS tramite AWS SDK per Java, sono necessarie le seguenti condizioni: + L'SDK Java deve avere accesso alle credenziali per [autenticare le richieste](get-started-auth.md#setup-auth) per conto dell'utente. + Le [autorizzazioni del ruolo IAM](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html) configurato per l'SDK devono consentire l'accesso a ciò che l' Servizi AWS applicazione richiede. Le autorizzazioni associate alla policy **PowerUserAccess** AWS gestita sono sufficienti per la maggior parte delle esigenze di sviluppo. + Un ambiente di sviluppo con i seguenti elementi: + [File di configurazione condivisi](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) configurati in almeno uno dei seguenti modi: + Il `config` file contiene le [impostazioni Single Sign-On di IAM Identity Center in](get-started-auth.md#setup-credentials) modo che l'SDK possa ottenere le credenziali. AWS + Il `credentials` file contiene credenziali temporanee. + Un'[installazione di Java 8](setup-java-buildtool.md) o versione successiva. + [Uno [strumento di automazione delle build](setup-java-buildtool.md) come [Maven o Gradle](https://maven.apache.org/download.cgi).](https://gradle.org/install/) + Un editor di testo per lavorare con il codice. + (Facoltativo, ma consigliato) Un IDE (ambiente di sviluppo integrato) come [IntelliJ IDEA](https://www.jetbrains.com/idea/download/#section=windows), [Eclipse o](https://www.eclipse.org/ide/). [NetBeans](https://netbeans.apache.org/front/main/download/index.html) Se utilizzi IntelliJ IDEA, puoi anche aggiungere [Kit di strumenti AWS per IntelliJ IDEA](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html) da integrare Servizi AWS direttamente nell'IDE per aiutarti a semplificare lo sviluppo. + Una sessione attiva del portale di AWS accesso quando si è pronti per eseguire l'applicazione. La usi AWS Command Line Interface per [avviare la procedura di accesso al portale di accesso](get-started-auth.md#setup-login-sso) di IAM Identity Center. AWS **Importante** Le istruzioni in questa sezione di configurazione presuppongono che tu o l'organizzazione utilizzi IAM Identity Center. Se la tua organizzazione utilizza un provider di identità esterno che funziona indipendentemente da IAM Identity Center, scopri come ottenere credenziali temporanee da utilizzare con l'SDK for Java. Segui [queste istruzioni](credentials-temporary.md#credentials-temporary-from-portal) per aggiungere credenziali temporanee al file. `~/.aws/credentials` Se il tuo provider di identità aggiunge automaticamente credenziali temporanee al `~/.aws/credentials` file, assicurati che il nome del profilo sia `[default]` tale da non dover fornire un nome di profilo all'SDK o. AWS CLI # Installa Java e uno strumento di compilazione per lavorare con AWS SDK for Java 2.x Sono necessari i seguenti requisiti dell'ambiente di sviluppo Java per lavorare con SDK for Java 2.x: + Java 8 o versione successiva. AWS SDK per Java [Funziona con l'[Oracle Java SE Development Kit](https://www.oracle.com/java/technologies/downloads/) e con le distribuzioni di Open Java Development Kit (OpenJDK) come [Red](https://developers.redhat.com/products/openjdk/overview) Hat OpenJDK e [Amazon Corretto](https://aws.amazon.com/corretto/)Adoptium.](https://adoptium.net/) + Strumenti di compilazione compatibili con Maven come Apache Maven, Apache Ant with Ivy, Gradle o IntelliJ. + [Per informazioni su come installare e utilizzare Maven, consulta https://maven.apache.org/.](https://maven.apache.org/) + [Per informazioni su come installare e utilizzare Apache Ivy, vedi https://ant.apache.org/ivy/.](https://ant.apache.org/ivy/) + [Per informazioni su come installare e utilizzare Gradle, consulta https://gradle.org/.](https://gradle.org/) + Per informazioni su come installare e utilizzare IntelliJ IDEA, vedere. [https://www.jetbrains.com/idea/](https://www.jetbrains.com/idea/) # Configura un progetto Apache Maven che utilizza AWS SDK for Java 2.x [Puoi usare [Apache Maven](https://maven.apache.org/) per configurare e creare AWS SDK for Java 2.x progetti o per creare l'SDK stesso.](https://github.com/aws/aws-sdk-java-v2/tree/master#building-from-source) ## Prerequisiti Per utilizzare l'SDK for Java 2.x con Maven, è necessario quanto segue: + Java *8.0 o versione successiva*. [È possibile scaricare il software Java SE Development Kit più recente da http://www.oracle. com/technetwork/java/javase/downloads](https://www.oracle.com/java/technologies/downloads/)/. L'SDK for Java 2.x funziona anche con [OpenJDK](https://openjdk.org/) Amazon Corretto e una distribuzione dell'Open Java Development Kit (OpenJDK). Scarica l'ultima versione di OpenJDK da. [https://openjdk.java.net/install/index.html](https://openjdk.org/install/index.html) [Scarica l'ultima versione Amazon Corretto 8 o Amazon Corretto 11 dalla pagina. Corretto](https://aws.amazon.com/corretto/) + *Apache Maven*. Se hai bisogno di installare Maven, vai su [http://maven.apache.org/](https://maven.apache.org/) per scaricarlo e installarlo. ## Creare un progetto Maven Per creare un progetto Maven dalla riga di comando, esegui il seguente comando da un terminale o da una finestra del prompt dei comandi. `` `` ``` mvn -B archetype:generate \ -DarchetypeGroupId=software.amazon.awssdk \ -DarchetypeArtifactId=archetype-lambda -Dservice=s3 -Dregion=US_WEST_2 \ -DarchetypeVersion=2.X.X \ -DgroupId=com.example.myapp \ -DartifactId=myapp ``` **Nota** Sostituisci *com.example.myapp* con lo spazio dei nomi del pacchetto completo dell'applicazione. Sostituisci anche *myapp* con il nome del tuo progetto. Questo sarà il nome della directory per il progetto. [Per utilizzare la versione più recente dell'archetipo, sostituiscila *2.X.X* con la più recente di Maven central.](https://central.sonatype.com/artifact/software.amazon.awssdk/archetype-lambda) Questo comando crea un progetto Maven utilizzando l'archetype templating toolkit. L'archetipo genera lo scaffolding per un progetto di gestione delle funzioni. AWS Lambda Questo archetipo di progetto è preconfigurato per la compilazione con Java SE 8 e include una dipendenza dalla versione dell'SDK for Java 2.x specificata con. `-DarchetypeVersion` Per ulteriori informazioni sulla creazione e la configurazione di progetti Maven, consulta la [Guida alle operazioni di base Maven](https://maven.apache.org/guides/getting-started/). ## Configurare il compilatore Java per Maven Se avete creato il progetto utilizzando l'archetipo del AWS Lambda progetto come descritto in precedenza, la configurazione del compilatore Java è già stata completata automaticamente. Per verificare che questa configurazione sia presente, inizia aprendo il file `pom.xml` dalla cartella del progetto creata (ad esempio `myapp`) quando hai eseguito il comando precedente. Guarda le righe 11 e 12 per vedere l'impostazione della versione del compilatore Java per questo progetto Maven e l'inclusione richiesta del plugin del compilatore Maven sulle righe 71-75. ``` 1.8 1.8 org.apache.maven.plugins maven-compiler-plugin ${maven.compiler.plugin.version} ``` Se crei il tuo progetto con un archetipo diverso o utilizzando un altro metodo, devi assicurarti che il plugin del compilatore Maven faccia parte della build e che le sue proprietà di origine e destinazione siano entrambe impostate su **1.8** nel file `pom.xml`. Vedi lo snippet precedente per una modalità di configurazione di tali impostazioni richieste. In alternativa, puoi impostare la configurazione del compilatore in linea con la dichiarazione del plugin, come segue. ``` org.apache.maven.plugins maven-compiler-plugin 1.8 1.8 ``` ## Dichiarare l'SDK come dipendenza Per utilizzarlo AWS SDK per Java nel progetto, è necessario dichiararlo come dipendenza nel file del progetto. `pom.xml` Se avete creato il progetto utilizzando l'archetipo del progetto come descritto in precedenza, l'ultima versione dell'SDK è già configurata come dipendenza nel progetto. L'archetipo genera una dipendenza dall'artefatto BOM (distinta dei materiali) per l'id del gruppo. `software.amazon.awssdk` Con un BOM, non è necessario specificare la versione Maven per le dipendenze dei singoli artefatti che condividono lo stesso ID di gruppo. Se hai creato il tuo progetto Maven in un modo diverso, configura l'ultima versione dell'SDK per il tuo progetto assicurandoti che il file `pom.xml` contenga quanto segue. ``` 2.X.X software.amazon.awssdk bom ${aws.java.sdk.version} pom import ``` **Nota** [Sostituisci il *2.X.X*`pom.xml` file con la versione più recente di. AWS SDK for Java 2.x](https://central.sonatype.com/artifact/software.amazon.awssdk/bom) ## Impostare le dipendenze per i moduli SDK Ora che hai configurato l'SDK, puoi aggiungere dipendenze per uno o più AWS SDK per Java moduli da utilizzare nel tuo progetto. Sebbene sia possibile specificare il numero di versione per ogni componente, non è necessario perché la versione SDK è già stata dichiarata nella `dependencyManagement` sezione utilizzando l'elemento della distinta base. Per caricare una versione diversa di un determinato modulo, specificate un numero di versione per la sua dipendenza. Se avete creato il progetto utilizzando l'archetipo del progetto come descritto in precedenza, il progetto è già configurato con dipendenze multiple. Queste includono le dipendenze per i gestori di AWS Lambda funzioni e Amazon S3, come segue. ``` software.amazon.awssdk s3 software.amazon.awssdk netty-nio-client software.amazon.awssdk apache-client software.amazon.awssdk url-connection-client com.amazonaws aws-lambda-java-core ${aws.lambda.java.version} ``` **Nota** Nell'`pom.xml`esempio precedente, le dipendenze provengono da diverse s. `groupId` La `s3` dipendenza proviene da`software.amazon.awssdk`, mentre la `aws-lambda-java-core` dipendenza proviene da. `com.amazonaws` La configurazione della gestione delle dipendenze BOM influisce sugli artefatti di`software.amazon.awssdk`, quindi è necessaria una versione per l'artefatto. `aws-lambda-java-core` Per lo sviluppo di *gestori di funzioni Lambda* utilizzando l'SDK for Java `aws-lambda-java-core` 2.x, è la dipendenza corretta. Tuttavia, se l'applicazione deve gestire le risorse Lambda, l'utilizzo di operazioni come `listFunctions` `deleteFunction``invokeFunction`,`createFunction`, e richiede la seguente dipendenza. ``` software.amazon.awssdk lambda ``` **Nota** La `s3` dipendenza esclude le dipendenze e le dipendenze transitive. `netty-nio-client` `apache-client` [Al posto di uno di questi client HTTP, l'archetipo include la `url-connection-client` dipendenza, che aiuta a ridurre la latenza di avvio delle funzioni. AWS Lambda](lambda-optimize-starttime.md#lambda-quick-url) Aggiungi i moduli al tuo progetto per le Servizio AWS funzionalità necessarie al tuo progetto. I moduli (dipendenze) gestiti dalla AWS SDK per Java BOM sono elencati nell'archivio centrale di [Maven](https://central.sonatype.com/artifact/software.amazon.awssdk/bom). **Nota** Puoi esaminare il file `pom.xml` da un esempio di codice per determinare di quali dipendenze hai bisogno per il tuo progetto. [Ad esempio, se sei interessato alle dipendenze per il servizio DynamoDB, [guarda questo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/dynamodb/pom.xml) esempio dal AWS Code Examples Repository su.](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2) GitHub [(Cerca il `pom.xml` file in /javav2/example\$1code/dynamodb.)](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/dynamodb) ### Creare l'intero SDK nel progetto Per ottimizzare l’applicazione, ti consigliamo di inserire solo i componenti necessari anziché tutto l'SDK. Tuttavia, per inserire il tutto AWS SDK per Java nel tuo progetto, dichiaralo nel tuo file, come segue. `pom.xml` ``` software.amazon.awssdk aws-sdk-java 2.X.X ``` ## Creare il progetto Dopo aver configurato il file `pom.xml`, puoi usare Maven per creare il tuo progetto. Per creare il tuo progetto Maven dalla riga di comando, apri un terminale o una finestra del prompt dei comandi, vai alla directory del progetto (ad esempio `myapp`), inserisci o incolla il seguente comando, quindi premi Enter o Invio. ``` mvn package ``` Viene così creato un singolo file `.jar` (JAR) nella directory `target` (ad esempio, `myapp/target`). Questo file JAR contiene tutti i moduli SDK specificati come dipendenze nel file `pom.xml`. # Configura un progetto Gradle che utilizza il AWS SDK for Java 2.x Puoi usare [Gradle](https://gradle.org/) per configurare e creare progetti. AWS SDK for Java 2.x I passaggi iniziali nell'esempio seguente provengono dalla [guida introduttiva di Gradle](https://docs.gradle.org/current/samples/sample_building_java_applications.html) per la versione 8.4. Se si utilizza una versione diversa, i risultati potrebbero differire leggermente. **Per creare un'applicazione Java con Gradle (riga di comando)** 1. Crea una cartella per contenere il tuo progetto. In questo esempio, `demo` è il nome della directory. 1. All'interno della `demo` directory, esegui il `gradle init` comando e fornisci i valori evidenziati in rosso, come mostrato nel seguente output della riga di comando. Per la procedura dettagliata, scegliamo Kotlin come linguaggio DSL per lo script di compilazione, ma alla fine di questo argomento viene mostrato anche un esempio completo di Groovy. ``` > gradle init Starting a Gradle Daemon (subsequent builds will be faster) Select type of project to generate: 1: basic 2: application 3: library 4: Gradle plugin Enter selection (default: basic) [1..4] 2 Select implementation language: 1: C++ 2: Groovy 3: Java 4: Kotlin 5: Scala 6: Swift Enter selection (default: Java) [1..6] 3 Generate multiple subprojects for application? (default: no) [yes, no] no Select build script DSL: 1: Kotlin 2: Groovy Enter selection (default: Kotlin) [1..2] Select test framework: 1: JUnit 4 2: TestNG 3: Spock 4: JUnit Jupiter Enter selection (default: JUnit Jupiter) [1..4] 4 Project name (default: demo): Source package (default: demo): Enter target version of Java (min. 7) (default: 11): Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no] > Task :init To learn more about Gradle by exploring our Samples at https://docs.gradle.org/8.4/samples/sample_building_java_applications.html BUILD SUCCESSFUL in 3m 43s 2 actionable tasks: 2 executed ``` 1. Al termine dell'`init`attività, la `demo` directory contiene la seguente struttura ad albero. Diamo un'occhiata più da vicino al file di build principale, `build.gradle.kts` (evidenziato in rosso), nella prossima sezione. ``` ├── app │   ├── build.gradle.kts │   └── src │   ├── main │   │   ├── java │   │   │   └── demo │   │   │   └── App.java │   │   └── resources │   └── test │   ├── java │   │   └── demo │   │   └── AppTest.java │   └── resources ├── gradle │   └── wrapper │   ├── gradle-wrapper.jar │   └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat └── settings.gradle.kts ``` Il `build.gradle.kts` file contiene il seguente contenuto strutturato. ``` /* * This file was generated by the Gradle 'init' task. * * This generated file contains a sample Java application project to get you started. * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.4/userguide/building_java_projects.html in the Gradle documentation. */ plugins { // Apply the application plugin to add support for building a CLI application in Java. application } repositories { // Use Maven Central for resolving dependencies. mavenCentral() } dependencies { // Use JUnit Jupiter for testing. testImplementation("org.junit.jupiter:junit-jupiter:5.9.3") testRuntimeOnly("org.junit.platform:junit-platform-launcher") // This dependency is used by the application. implementation("com.google.guava:guava:33.3.0-jre") } // Apply a specific Java toolchain to ease working on different environments. java { toolchain { languageVersion.set(JavaLanguageVersion.of(11)) } } application { // Define the main class for the application. mainClass.set("demo.App") } tasks.named("test") { // Use JUnit Platform for unit tests. useJUnitPlatform() } ``` 1. Usa il file di build Gradle impalcaturato come base per il tuo progetto. AWS 1. Per gestire le dipendenze SDK per il tuo progetto Gradle, aggiungi la distinta base (BOM) di Maven alla sezione del file. AWS SDK for Java 2.x `dependencies` `build.gradle.kts` ``` ... dependencies { implementation(platform("software.amazon.awssdk:bom:2.27.21")) // With the bom declared, you specify individual SDK dependencies without a version. ... } ... ``` **Nota** In questo file di build di esempio, sostituisci *2.27.21* con l'ultima versione di SDK for Java 2.x. [Trova l'ultima versione disponibile nel repository centrale di Maven.](https://central.sonatype.com/artifact/software.amazon.awssdk/bom/versions) 1. Specificate i moduli SDK necessari alla vostra applicazione nella sezione. `dependencies` Ad esempio, quanto segue aggiunge una dipendenza da Amazon Simple Storage Service. ``` ... dependencies { implementation(platform("software.amazon.awssdk:bom:2.27.21")) implementation("software.amazon.awssdk:s3") ... } ... ``` Gradle risolve automaticamente la versione corretta delle dipendenze dichiarate utilizzando le informazioni della BOM. Gli esempi seguenti mostrano i file di build Gradle completi sia in Kotlin che in Groovy. DSLs Il file di build contiene dipendenze per Amazon S3, autenticazione, registrazione e test. La versione di origine e di destinazione di Java è la versione 11. ------ #### [ Kotlin DSL (build.gradle.kts) ] ``` /* * This file was generated by the Gradle 'init' task. * * This generated file contains a sample Java application project to get you started. * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.4/userguide/building_java_projects.html in the Gradle documentation. */ plugins { // Apply the application plugin to add support for building a CLI application in Java. application } repositories { // Use Maven Central for resolving dependencies. mavenCentral() } dependencies { implementation(platform("software.amazon.awssdk:bom:2.20.56")) implementation("software.amazon.awssdk:s3") implementation("software.amazon.awssdk:sso") implementation("software.amazon.awssdk:ssooidc") implementation(platform("org.apache.logging.log4j:log4j-bom:2.20.0")) implementation("org.apache.logging.log4j:log4j-slf4j2-impl") implementation("org.apache.logging.log4j:log4j-1.2-api") testImplementation(platform("org.junit:junit-bom:5.10.0")) testImplementation("org.junit.jupiter:junit-jupiter") } // Apply a specific Java toolchain to ease working on different environments. java { toolchain { languageVersion.set(JavaLanguageVersion.of(11)) } } application { // Define the main class for the application. mainClass.set("demo.App") } tasks.named("test") { // Use JUnit Platform for unit tests. useJUnitPlatform() } ``` ------ #### [ Groovy DSL (build.gradle) ] ``` /* * This file was generated by the Gradle 'init' task. * * This generated file contains a sample Java application project to get you started. * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.4/userguide/building_java_projects.html in the Gradle documentation. */ plugins { // Apply the application plugin to add support for building a CLI application in Java. id 'application' } repositories { // Use Maven Central for resolving dependencies. mavenCentral() } dependencies { implementation platform('software.amazon.awssdk:bom:2.27.21') implementation 'software.amazon.awssdk:s3' implementation 'software.amazon.awssdk:sso' implementation 'software.amazon.awssdk:ssooidc' implementation platform('org.apache.logging.log4j:log4j-bom:2.20.0') implementation 'org.apache.logging.log4j:log4j-slf4j2-impl' implementation 'org.apache.logging.log4j:log4j-1.2-api' testImplementation platform('org.junit:junit-bom:5.10.0') testImplementation 'org.junit.jupiter:junit-jupiter' } // Apply a specific Java toolchain to ease working on different environments. java { toolchain { languageVersion = JavaLanguageVersion.of(11) } } application { // Define the main class for the application. mainClass = 'demo_groovy.App' } tasks.named('test') { // Use JUnit Platform for unit tests. useJUnitPlatform() } ``` ------ Per i passaggi successivi, consulta la guida introduttiva sul sito Web di Gradle per istruzioni su come [creare ed eseguire un'applicazione Gradle](https://docs.gradle.org/current/samples/sample_building_java_applications.html#run_the_application). # Configura un progetto GraalVM Native Image che utilizza AWS SDK for Java 2.x Con le versioni 2.16.1 e successive, AWS SDK for Java 2.x fornisce out-of-the-box supporto per le applicazioni GraalVM Native Image. Usa l'archetipo `archetype-app-quickstart` Maven per configurare un progetto con supporto di immagini nativo integrato. ## Prerequisiti + Completa i passaggi descritti in [Configurazione](setup.md) del 2.x. AWS SDK per Java + Installa [GraalVM Native Image](https://www.graalvm.org/reference-manual/native-image/#install-native-image). ## Crea un progetto usando l'archetipo Per creare un progetto Maven con supporto per immagini native integrato, in un terminale o in una finestra del prompt dei comandi, usa il seguente comando. **Nota** `com.example.mynativeimageapp`Sostituiscilo con lo spazio dei nomi completo del pacchetto dell'applicazione. Sostituiscilo anche `mynativeimageapp` con il nome del tuo progetto. Questo sarà il nome della directory per il progetto. ``` mvn archetype:generate \ -DarchetypeGroupId=software.amazon.awssdk \ -DarchetypeArtifactId=archetype-app-quickstart \ -DarchetypeVersion=2.27.21\ -DnativeImage=true \ -DhttpClient=apache-client \ -Dservice=s3 \ -DgroupId=com.example.mynativeimageapp \ -DartifactId=mynativeimageapp \ -DinteractiveMode=false ``` Questo comando crea un progetto Maven configurato con dipendenze per AWS SDK per Java Amazon S3, e il `ApacheHttpClient` client HTTP. Include anche una dipendenza per il [plug-in GraalVM Native Image Maven, in modo da poter creare immagini native utilizzando Maven](https://graalvm.github.io/native-build-tools/latest/index.html). Per includere le dipendenze per un altro servizio Amazon Web Services, imposta il valore del parametro sull'ID dell'artefatto di quel servizio. `-Dservice` Esempi includono `dynamodb`, `comprehend` e `pinpoint`. [Per un elenco completo degli elementi IDs, consulta l'elenco delle dipendenze gestite per software.amazon.awssdk su Maven Central.](https://mvnrepository.com/artifact/software.amazon.awssdk/bom/latest) Per utilizzare un client HTTP `-DhttpClient` `netty-nio-client` asincrono, imposta il parametro su. Per utilizzarlo invece `UrlConnectionHttpClient` come client HTTP sincrono`apache-client`, imposta il parametro su. `-DhttpClient` `url-connection-client` ## Crea un'immagine nativa Dopo aver creato il progetto, esegui il seguente comando dalla directory del progetto, ad esempio`mynativeimageapp`: ``` mvn package -P native-image ``` In questo modo viene creata un'applicazione di immagini nativa nella `target` directory, ad esempio`target/mynativeimageapp`. # Autenticazione con l'utilizzo di AWS AWS SDK for Java 2.x È necessario stabilire la modalità di AWS SDK for Java 2.x autenticazione AWS quando si sviluppa con i servizi. AWS L'SDK gestisce l'individuazione delle credenziali, la creazione delle firme e l'aggiornamento delle credenziali completamente in background, consentendoti di concentrarti sulla logica dell'applicazione. ## Configurazione per l'autenticazione L'argomento [Autenticazione e accesso](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) nella Guida di riferimento agli strumenti AWS SDKs e agli strumenti descrive i diversi approcci di autenticazione. Per lo sviluppo locale, l'approccio consigliato consiste nell'utilizzare credenziali a breve termine accedendo alla AWS CLI con le credenziali di accesso della console. Consigliato se utilizzi utenti root, IAM o federazione con IAM per l'accesso all'account. AWS Segui le istruzioni riportate in [Credenziali di accesso per il lavoro di sviluppo interattivo utilizzando AWS SDK for Java 2.x](credentials-temporary.md). Dopo aver seguito le istruzioni contenute nella AWS SDKs Tools Reference Guide, il sistema dovrebbe essere configurato in modo da consentire all'SDK di firmare le richieste: ### 1. Sviluppo locale utilizzando credenziali a breve termine Per lo sviluppo locale, l'approccio consigliato consiste nell'utilizzare credenziali a breve termine accedendo alla AWS CLI con le credenziali di accesso della console. Consigliato se utilizzi utenti root, IAM o federazione con IAM per l'accesso all'account. AWS Per istruzioni, consulta [Utilizzo dei provider di credenziali in](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials-temporary.html). AWS SDK for Java 2.x ### 2. Configurazione per l'accesso Single Sign-On per l'SDK Dopo aver completato il passaggio 2 nella [sezione sull'accesso programmatico](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html#idcGettingStarted) in modo che l'SDK possa utilizzare l'autenticazione IAM Identity Center, il sistema dovrebbe contenere i seguenti elementi. + Il AWS CLI, che viene utilizzato per avviare una [sessione del portale di AWS accesso](#setup-login-sso) prima di eseguire l'applicazione. + Un `~/.aws/config` file che contiene un [profilo predefinito](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile). L'SDK for Java utilizza la configurazione del provider di token SSO del profilo per acquisire le credenziali prima di inviare richieste a. AWS Il valore `sso_role_name`, che è un ruolo IAM connesso a un set di autorizzazioni di IAM Identity Center, dovrebbe consentire l'accesso ai Servizi AWS utilizzati nell'applicazione. Il seguente `config` file di esempio mostra un profilo predefinito impostato con la configurazione del provider di token SSO. L'impostazione `sso_session` del profilo si riferisce alla sezione `sso-session` denominata. La sezione `sso-session` contiene le impostazioni per avviare una sessione del portale di accesso AWS . ``` [default] sso_session = my-sso sso_account_id = 111122223333 sso_role_name = SampleRole region = us-east-1 output = json [sso-session my-sso] sso_region = us-east-1 sso_start_url = https://provided-domain.awsapps.com/start sso_registration_scopes = sso:account:access ``` Per maggiori dettagli sulle impostazioni utilizzate nella configurazione del provider di token SSO, consulta Configurazione del provider di [token SSO nella AWS SDKs and Tools Reference](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#sso-token-config) Guide. Se l'ambiente di sviluppo non è configurato per l'accesso programmatico come mostrato in precedenza, segui il [passaggio 2 della SDKs Guida di riferimento](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html#idcGettingStarted). ### 3. Effettuate l'accesso utilizzando il AWS CLI Prima di eseguire un'applicazione che consente l'accesso Servizi AWS, è necessaria una sessione attiva del portale di AWS accesso affinché l'SDK utilizzi l'autenticazione IAM Identity Center per risolvere le credenziali. Esegui il seguente comando in AWS CLI per accedere al portale di accesso. AWS ``` aws sso login ``` Poiché disponi di una configurazione predefinita del profilo, non devi chiamare il comando con un'opzione `--profile`. Se la configurazione del provider di token SSO utilizza un profilo denominato, il comando è `aws sso login --profile named-profile`. Per verificare se hai già una sessione attiva, esegui il seguente comando AWS CLI . ``` aws sts get-caller-identity ``` La risposta a questo comando dovrebbe restituire l'account IAM Identity Center e il set di autorizzazioni configurati nel file `config` condiviso. **Nota** Se hai già una sessione attiva del portale di AWS accesso ed esegui`aws sso login`, non ti verrà richiesto di fornire credenziali. Tuttavia, verrà visualizzata una finestra di dialogo che richiede l'autorizzazione per accedere `botocore` alle informazioni. `botocore`è la base per AWS CLI . Seleziona **Consenti** per autorizzare l'accesso alle tue informazioni per AWS CLI e SDK for Java. ## Opzioni di autenticazione aggiuntive Per ulteriori opzioni sull'autenticazione per l'SDK, come l'uso di profili e variabili di ambiente, consultate il capitolo sulla [configurazione](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) nella Guida di riferimento agli strumenti AWS SDKs e agli strumenti. # Creazione di una semplice applicazione utilizzando AWS SDK for Java 2.x Questo tutorial mostra come utilizzare [Apache Maven](https://maven.apache.org/) per definire le dipendenze per l'SDK for Java 2.x e quindi scrivere codice che si connette a per caricare un file. Amazon S3 Segui questi passaggi per completare questo tutorial: + [Fase 1: Configurazione per questo tutorial](#get-started-setup) + [Fase 2: Creare il progetto](#get-started-projectsetup) + [Fase 3: Scrivere il codice](#get-started-code) + [Fase 4: Compilare ed eseguire l'applicazione](#get-started-run) ## Fase 1: prepararsi per il tutorial Prima di iniziare questo tutorial, servirà quanto segue: + Autorizzazione all'accesso Amazon S3 + Un ambiente di sviluppo Java configurato per accedere Servizi AWS tramite Single Sign-On a AWS IAM Identity Center Usa le istruzioni riportate in questa guida [Panoramica della configurazione](setup.md#setup-overview) per prepararti a questo tutorial. Dopo aver [configurato l'ambiente di sviluppo con l'accesso Single Sign-On per Java SDK e aver avuto una sessione attiva sul](get-started-auth.md#setup-credentials) [portale di AWS accesso](get-started-auth.md#setup-login-sso), continua con la Fase 2 di questo tutorial. ## Fase 2: creare il progetto Per creare il progetto per questo tutorial, si esegue un comando Maven che richiede input su come configurare il progetto. Dopo aver inserito e confermato tutti gli input, Maven completa la creazione del progetto creando un `pom.xml` file Java stub. 1. Apri un terminale o una finestra del prompt dei comandi e accedi a una directory a tua scelta, ad esempio il `Desktop` o la cartella `Home`. 1. Immettete il seguente comando nel terminale e premete. `Enter` ``` mvn archetype:generate \ -DarchetypeGroupId=software.amazon.awssdk \ -DarchetypeArtifactId=archetype-app-quickstart \ -DarchetypeVersion=2.27.21 ``` 1. Immettete il valore elencato nella seconda colonna per ogni prompt. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sdk-for-java/latest/developer-guide/get-started-tutorial.html) 1. Dopo aver inserito l'ultimo valore, Maven elenca le scelte effettuate. Conferma inserendo *`Y`*o reinserisci i valori inserendo. *`N`* Maven crea la cartella di progetto denominata `getstarted` in base al `artifactId` valore inserito. All'interno della `getstarted` cartella, trova un `README.md` file che puoi rivedere, un `pom.xml` file e una `src` directory. Maven crea la seguente struttura di cartelle. ``` getstarted ├── README.md ├── pom.xml └── src ├── main │   ├── java │   │   └── org │   │   └── example │   │   ├── App.java │   │   ├── DependencyFactory.java │   │   └── Handler.java │   └── resources │   └── simplelogger.properties └── test └── java └── org └── example └── HandlerTest.java 10 directories, 7 files ``` Di seguito viene mostrato il contenuto del file di progetto `pom.xml`. ### `pom.xml` La `dependencyManagement` sezione contiene una dipendenza da AWS SDK for Java 2.x e la `dependencies` sezione ha una dipendenza per Amazon S3. Il progetto utilizza Java 1.8 a causa del valore `1.8` delle proprietà `maven.compiler.source` e `maven.compiler.target`. ``` 4.0.0 org.example getstarted 1.0-SNAPSHOT jar UTF-8 1.8 1.8 3.2.1 3.6.1 1.6.0 2.27.21 <-------- SDK version picked up from archetype version. 1.7.28 5.8.1 software.amazon.awssdk bom ${aws.java.sdk.version} pom import software.amazon.awssdk s3 <-------- S3 dependency software.amazon.awssdk netty-nio-client software.amazon.awssdk apache-client software.amazon.awssdk sso <-------- Required for identity center authentication. software.amazon.awssdk ssooidc <-------- Required for identity center authentication. software.amazon.awssdk apache-client <-------- HTTP client specified. commons-logging commons-logging org.slf4j slf4j-api ${slf4j.version} org.slf4j slf4j-simple ${slf4j.version} org.slf4j jcl-over-slf4j ${slf4j.version} org.junit.jupiter junit-jupiter ${junit5.version} test org.apache.maven.plugins maven-compiler-plugin ${maven.compiler.plugin.version} ``` ## Fase 3: scrivere il codice Il codice seguente mostra la `App` classe creata da Maven. Il metodo `main` è il punto di ingresso nell’applicazione, che crea un’istanza della classe `Handler` e quindi ne richiama il metodo `sendRequest`. ### Classe `App` ``` package org.example; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class App { private static final Logger logger = LoggerFactory.getLogger(App.class); public static void main(String... args) { logger.info("Application starts"); Handler handler = new Handler(); handler.sendRequest(); logger.info("Application ends"); } } ``` La `DependencyFactory` classe creata da Maven contiene il metodo `s3Client` factory che crea e restituisce un'istanza. [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html) L’istanza `S3Client` utilizza un’istanza del client HTTP basato su Apache. Questo avviene perché si specifica `apache-client` quando Maven chiede quale client HTTP usare. `DependencyFactory`È mostrato nel codice seguente. ### Classe `DependencyFactory` ``` package org.example; import software.amazon.awssdk.http.apache.ApacheHttpClient; import software.amazon.awssdk.services.s3.S3Client; /** * The module containing all dependencies required by the {@link Handler}. */ public class DependencyFactory { private DependencyFactory() {} /** * @return an instance of S3Client */ public static S3Client s3Client() { return S3Client.builder() .httpClientBuilder(ApacheHttpClient.builder()) .build(); } } ``` La classe `Handler` contiene la logica principale del programma. Quando viene creata un’istanza di `Handler` nella classe `App`, `DependencyFactory` fornisce il servizio client `S3Client`. Il codice utilizza l'`S3Client`istanza per chiamare il servizio Amazon S3. Maven genera la seguente classe `Handler` con un commento `TODO`. Il passaggio successivo del tutorial sostituisce il codice *`TODO`*with. ### Classe `Handler`, generata da Maven ``` package org.example; import software.amazon.awssdk.services.s3.S3Client; public class Handler { private final S3Client s3Client; public Handler() { s3Client = DependencyFactory.s3Client(); } public void sendRequest() { // TODO: invoking the api calls using s3Client. } } ``` Per compilare la logica, sostituisci l’intero contenuto della classe `Handler` con il codice seguente. Il metodo `sendRequest` viene compilato e vengono aggiunte le importazioni necessarie. ### Classe `Handler`, implementata Il codice crea innanzitutto un nuovo bucket S3 con l'ultima parte del nome generata utilizzando per rendere `System.currentTimeMillis()` unico il nome del bucket. Dopo aver creato il bucket nel `createBucket()` metodo, il programma carica un oggetto utilizzando il metodo di. [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html#putObject(software.amazon.awssdk.services.s3.model.PutObjectRequest,software.amazon.awssdk.core.sync.RequestBody)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html#putObject(software.amazon.awssdk.services.s3.model.PutObjectRequest,software.amazon.awssdk.core.sync.RequestBody))`S3Client` Il contenuto dell'oggetto è una semplice stringa creata con il `RequestBody.fromString` metodo. Infine, il programma elimina l'oggetto seguito dal bucket nel `cleanUp` metodo. ``` package org.example; import software.amazon.awssdk.core.sync.RequestBody; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.CreateBucketRequest; import software.amazon.awssdk.services.s3.model.DeleteBucketRequest; import software.amazon.awssdk.services.s3.model.DeleteObjectRequest; import software.amazon.awssdk.services.s3.model.HeadBucketRequest; import software.amazon.awssdk.services.s3.model.PutObjectRequest; import software.amazon.awssdk.services.s3.model.S3Exception; public class Handler { private final S3Client s3Client; public Handler() { s3Client = DependencyFactory.s3Client(); } public void sendRequest() { String bucket = "bucket" + System.currentTimeMillis(); String key = "key"; createBucket(s3Client, bucket); System.out.println("Uploading object..."); s3Client.putObject(PutObjectRequest.builder().bucket(bucket).key(key) .build(), RequestBody.fromString("Testing with the {sdk-java}")); System.out.println("Upload complete"); System.out.printf("%n"); cleanUp(s3Client, bucket, key); System.out.println("Closing the connection to {S3}"); s3Client.close(); System.out.println("Connection closed"); System.out.println("Exiting..."); } public static void createBucket(S3Client s3Client, String bucketName) { try { s3Client.createBucket(CreateBucketRequest .builder() .bucket(bucketName) .build()); System.out.println("Creating bucket: " + bucketName); s3Client.waiter().waitUntilBucketExists(HeadBucketRequest.builder() .bucket(bucketName) .build()); System.out.println(bucketName + " is ready."); System.out.printf("%n"); } catch (S3Exception e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } } public static void cleanUp(S3Client s3Client, String bucketName, String keyName) { System.out.println("Cleaning up..."); try { System.out.println("Deleting object: " + keyName); DeleteObjectRequest deleteObjectRequest = DeleteObjectRequest.builder().bucket(bucketName).key(keyName).build(); s3Client.deleteObject(deleteObjectRequest); System.out.println(keyName + " has been deleted."); System.out.println("Deleting bucket: " + bucketName); DeleteBucketRequest deleteBucketRequest = DeleteBucketRequest.builder().bucket(bucketName).build(); s3Client.deleteBucket(deleteBucketRequest); System.out.println(bucketName + " has been deleted."); System.out.printf("%n"); } catch (S3Exception e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } System.out.println("Cleanup complete"); System.out.printf("%n"); } } ``` ## Fase 4: creare ed eseguire l’applicazione Dopo che il progetto è stato creato e contiene la `Handler` classe completa, create ed eseguite l'applicazione. 1. Assicurati di avere una sessione IAM Identity Center attiva. Per farlo, esegui il AWS Command Line Interface comando `aws sts get-caller-identity` e controlla la risposta. Se non hai una sessione attiva, consulta [questa sezione](get-started-auth.md#setup-login-sso) per le istruzioni. 1. Apri un terminale o una finestra del prompt dei comandi e vai alla directory del progetto `getstarted`. 1. Usa il seguente comando per creare il tuo progetto: ``` mvn clean package ``` 1. Utilizzate il seguente comando per eseguire l'applicazione. ``` mvn exec:java -Dexec.mainClass="org.example.App" ``` Per visualizzare il nuovo bucket e l'oggetto creati dal programma, effettuate le seguenti operazioni. 1. In`Handler.java`, commenta la riga `cleanUp(s3Client, bucket, key)` del `sendRequest` metodo e salva il file. 1. Ricostruisci il progetto `mvn clean package` eseguendo. 1. Esegui nuovamente `mvn exec:java -Dexec.mainClass="org.example.App"` per caricare l'oggetto di testo ancora una volta. 1. Accedi [alla console S3](https://console.aws.amazon.com/s3/) per visualizzare il nuovo oggetto nel bucket appena creato. Dopo aver visualizzato il file, elimina l’oggetto e quindi elimina il bucket. ### Completato Se il progetto Maven è stato creato ed eseguito senza errori, congratulazioni\$1 Hai creato con successo la tua prima applicazione Java utilizzando l'SDK for Java 2.x. ### Pulizia Per ripulire le risorse create durante questo tutorial, procedi come segue: + Se non l'hai già fatto, [nella console S3](https://console.aws.amazon.com/s3/), elimina tutti gli oggetti e i bucket creati durante l'esecuzione dell'applicazione. + Elimina la cartella del progetto ()`getstarted`. ## Fasi successive Ora che hai le nozioni di base, puoi scoprire quanto segue: + [Lavorare con Amazon S3](examples-s3.md) + [Lavorare con altri Amazon Web Services](work-with-services.md), ad esempio [DynamoDB[Amazon EC2](examples-ec2.md)](examples-dynamodb.md), e [vari servizi di database](examples-databases.md) + [Usa l'SDK](using.md) + [Sicurezza per AWS SDK per Java](security.md) **