SDK AWS per Java Developer Guide - SDK AWS per Java: Developer Guide - Amazon.com

Pagina creata da Riccardo Giuliano
 
CONTINUA A LEGGERE
SDK AWS per Java
                                   Developer Guide

SDK AWS per Java: Developer Guide
Copyright © 2018 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.
SDK AWS per Java Developer Guide

Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner
that is likely to cause confusion among customers, or in any manner that disparages or discredits Amazon. All other trademarks not
owned by Amazon are the property of their respective owners, who may or may not be affiliated with, connected to, or sponsored by
Amazon.
SDK AWS per Java Developer Guide

Table of Contents
  Guida per sviluppatori di SDK AWS per Java 2.0 ................................................................................... 1
         Novità della versione 2.0 ............................................................................................................. 1
         Supporto per 1.0 ........................................................................................................................ 1
         Altre risorse ............................................................................................................................... 1
         Contribuire all'anteprima per sviluppatori ........................................................................................ 1
         Supporto per IDE Eclipse ............................................................................................................ 2
         Sviluppo di applicazioni AWS per Android ...................................................................................... 2
  Nozioni di base .................................................................................................................................. 3
         Registrazione ad AWS e creazione di un utente IAM ...................................................................... 3
         Configurazione dell'SDK .............................................................................................................. 4
                Prerequisiti ........................................................................................................................ 4
                Includere l'SDK nel progetto ................................................................................................. 4
                Compilazione dell'SDK ........................................................................................................ 4
                Installazione di un ambiente di sviluppo Java .......................................................................... 5
                Selezione di una JVM ......................................................................................................... 5
         Configurazione della regione e delle credenziali di AWS ................................................................... 5
                Impostazione delle credenziali di AWS ................................................................................... 5
                Impostazione della regione AWS .......................................................................................... 6
         Utilizzo di SDK con Apache Maven .............................................................................................. 7
                Creazione di un nuovo pacchetto Maven ................................................................................ 7
                Configurazione di SDK come una dipendenza Maven ............................................................... 8
                Creazione del progetto ........................................................................................................ 9
         Utilizzo di SDK con Gradle ......................................................................................................... 9
  Utilizzo della SDK ............................................................................................................................. 12
         Creazione di client del servizio .................................................................................................. 12
                Ottenere un generatore client ............................................................................................. 12
                Utilizzo di DefaultClient ...................................................................................................... 13
                Ciclo di vita del client ........................................................................................................ 13
         Utilizzo di credenziali di AWS .................................................................................................... 13
                Utilizzo della catena di provider delle credenziali predefinita ..................................................... 13
                Specifica di un provider delle credenziali o catena di provider .................................................. 16
                Specifica in maniera esplicita delle credenziali ....................................................................... 16
                Ulteriori informazioni .......................................................................................................... 16
         Selezione di regioni AWS ......................................................................................................... 17
                Scelta di una regione ........................................................................................................ 17
                Scelta di un endpoint specifico ............................................................................................ 17
                Determinazione automatica della regione AWS dall'ambiente ................................................... 18
                Verifica della disponibilità del servizio in una regione AWS ...................................................... 18
         Programmazione asincrona ....................................................................................................... 19
                Operazioni non di streaming ............................................................................................... 19
                Operazioni di streaming ..................................................................................................... 20
         Programmazione HTTP/2 .......................................................................................................... 21
         Gestione delle eccezioni ........................................................................................................... 21
                Perché eccezioni non controllate? ....................................................................................... 22
                SdkServiceException (e sottoclassi) ..................................................................................... 22
                SdkClientException ............................................................................................................ 22
         Registrazione delle chiamate di AWS SDK for Java ...................................................................... 22
                Aggiunta di JAR Log4J ...................................................................................................... 23
                File di configurazione Log4j ................................................................................................ 23
                Impostazione di classpath .................................................................................................. 23
                Errori e avvertenze specifici del servizio ............................................................................... 23
                Registrazione del riepilogo di richieste/risposte ...................................................................... 24
                Registrazione in rete Verbose ............................................................................................. 24
         Configurazione di ruoli IAM per Amazon EC2 (Avanzate) ............................................................... 25

                                                                         iii
SDK AWS per Java Developer Guide

           Catena di provider predefinita e profili delle istanze Amazon EC2 ............................................. 25
           Procedura guidata: Utilizzo di ruoli IAM per istanze Amazon EC2 ............................................. 26
Esempi di codice .............................................................................................................................. 28
     Esempi Amazon S3 (Anteprima per sviluppatori) ............................................................................ 28
           Operazioni relative ai bucket .............................................................................................. 28
           Operazioni sugli oggetti ..................................................................................................... 31
     Esempi di Amazon SQS (Anteprima per sviluppatori) ..................................................................... 34
           Operazioni sulle code ........................................................................................................ 34
           Operazioni sui messaggi .................................................................................................... 36
     Esempi di Amazon CloudWatch .................................................................................................. 38
           Recupero di parametri da CloudWatch ................................................................................ 39
           Pubblicazione di dati dei parametri personalizzati .................................................................. 40
           Utilizzo di allarmi CloudWatch ............................................................................................ 41
           Utilizzo di operazioni di allarme in CloudWatch ..................................................................... 43
           Invio di eventi ad CloudWatch ........................................................................................... 45
     Esempi di Amazon DynamoDB ................................................................................................... 47
           Utilizzo delle tabelle in DynamoDB ..................................................................................... 47
           Uso di item in DynamoDB ................................................................................................. 53
     Esempi di Amazon EC2 (Anteprima per sviluppatori) ...................................................................... 56
           Gestione di istanze Amazon EC2 ....................................................................................... 56
           Utilizzo degli indirizzi IP elastici in Amazon EC2 ................................................................... 60
           Utilizzo di regioni e zone di disponibilità .............................................................................. 62
           Utilizzo di coppie di chiavi di Amazon EC2 .......................................................................... 64
           Lavorare con i gruppi di sicurezza in Amazon EC2 ............................................................... 65
     Esempi di AWS Identity and Access Management (IAM) (Anteprima per sviluppatori) ........................... 68
           Gestione delle chiavi di accessoIAM ................................................................................... 68
           Gestione degli utenti IAM .................................................................................................. 72
           Utilizzo di alias per l'account IAM ....................................................................................... 74
           Lavorare con le policy IAM ................................................................................................ 76
           Utilizzo dei certificati del server IAM ................................................................................... 80
     Esempi di Amazon Kinesis ......................................................................................................... 83
           Sottoscrizione ai flussi Amazon Kinesis ............................................................................... 83
     Esempi di paginazione ............................................................................................................... 88
           Paginazione sincrona ........................................................................................................ 88
           Impaginazione asincrona .................................................................................................... 90
Cronologia dei documenti ................................................................................................................... 94

                                                                     iv
SDK AWS per Java Developer Guide
                                        Novità della versione 2.0

Guida per sviluppatori di SDK AWS
per Java 2.0
     SDK AWS per Java fornisce un'API di Java per Amazon Web Services. Utilizzando l'SDK, puoi creare
     facilmente applicazioni Java che funzionano con Amazon S3, Amazon EC2, DynamoDB e molto altro.
     Regolarmente, aggiungiamo ad AWS SDK for Java il supporto per nuovi servizi. Per un elenco delle
     modifiche e delle caratteristiche in una particolare versione, visualizza il change log.

Novità della versione 2.0
     AWS SDK for Java 2.0 è una riscrittura principale della base di codice della versione 1.x. È stata sviluppata
     su base Java 8 e aggiunge diverse caratteristiche richieste frequentemente. Queste includono il supporto
     per I/O senza blocchi e la possibilità di connettere un'implementazione HTTP diversa durante il runtime.
     Per ulteriori informazioni, consulta il Blog AWS.
         Important

         Attualmente i moduli Amazon Kinesis, Amazon DynamoDB e Amazon CloudWatch nella versione
         2.0 sono pronti per la produzione e possono essere utilizzati in ambienti di produzione. Tutti gli altri
         moduli sono versioni di anteprima e non sono consigliati per l'uso in produzione.

Supporto per 1.0
     Attualmente, non stiamo ritirando il supporto per le versioni 1.x di SDK AWS per Java. Poiché ci stiamo
     avvicinando al rilascio di produzione finale, condivideremo un piano dettagliato per il supporto 1.x
     continuato, in modo simile all'introduzione di versioni principali di altri SDK AWS.

Altre risorse
     Oltre a questa guida, di seguito sono elencate altre risorse online preziose per sviluppatori AWS SDK for
     Java.

     • Informazioni di riferimento di SDK AWS per Java 2.0
     • Blog per gli sviluppatori Java
     • Forum per gli sviluppatori Java
     • GitHub:
       • Origine documentazione
       • Origine SDK
     • @awsforjava (Twitter)

Contribuire all'anteprima per sviluppatori
     Gli sviluppatori possono anche contribuire con commenti tramite i seguenti canali:

                                                      1
SDK AWS per Java Developer Guide
                                    Supporto per IDE Eclipse

    • Inviando problemi su GitHub:
      • Inviando problemi di documentazione
      • Inviando problemi SDK
    • Partecipando a una chat informale su SDK nel canale gitter AWS SDK for Java 2.0
    • Inviando commenti in maniera anonima all'indirizzo aws-java-sdk-v2-feedback@amazon.com. Questa e-
      mail è monitorata dal team di SDK AWS per Java.
    • Inviando richieste pull negli archivi GitHub della documentazione o origine SDK per contribuire allo
      sviluppo dell'SDK.

Supporto per IDE Eclipse
    AWS Toolkit for Eclipse non supporta attualmente AWS SDK for Java 2.0. Per utilizzare AWS Toolkit for
    Eclipse con AWS SDK for Java 2.0, utilizza gli strumenti Maven in Eclipse per aggiungere una dipendenza
    sull'SDK 2.0.

Sviluppo di applicazioni AWS per Android
    Per gli sviluppatori Android, Amazon Web Services pubblica un SDK creato specificamente per lo sviluppo
    di applicazioni Android: AWS Mobile SDK per Android. Per la documentazione completa, consulta la Guida
    per sviluppatori AWS Mobile SDK per Android.

                                                 2
SDK AWS per Java Developer Guide
                           Registrazione ad AWS e creazione di un utente IAM

Nozioni di base su AWS SDK for
Java 2.0 (Anteprima per sviluppatori)
    In questa sezione vengono fornite informazioni su come installare, configurare e utilizzare AWS SDK for
    Java.

    Argomenti
     • Registrazione ad AWS e creazione di un utente IAM (p. 3)
     • Configurazione di AWS SDK for Java 2.0 (Anteprima per sviluppatori) (p. 4)
     • Configurazione della regione e delle credenziali per lo sviluppo di AWS (p. 5)
     • Utilizzo di SDK con Apache Maven (p. 7)
     • Utilizzo di SDK con Gradle (p. 9)

Registrazione ad AWS e creazione di un utente IAM
    Per utilizzare AWS SDK for Java per accedere ad Amazon Web Services (AWS), occorre un account AWS
    e credenziali AWS. Per rafforzare la sicurezza dell'account AWS, ti consigliamo di utilizzare un utente IAM
    per fornire le credenziali di accesso anziché utilizzare le credenziali dell'account AWS.
         Note

         Per una panoramica di utenti IAM e perché sono importanti per la sicurezza dell'account, consulta
         Credenziali di sicurezza AWS nella Amazon Web Services General Reference.

    Registrazione ad AWS

    1.   Aprire https://aws.amazon.com/ e fare clic su Sign Up (Registrati).
    2.   Seguire le istruzioni a video. Parte della procedura di registrazione implica la ricezione di una chiamata
         telefonica e l'inserimento di un PIN usando la tastiera del telefono.

    Quindi, creare un utente IAM e scaricare (o copiare) la relativa chiave di accesso segreta.

    Per creare un utente IAM

    1.   Passare a IAM console (Console IAM) (potrebbe essere necessario prima accedere ad AWS).
    2.   Fare clic su Users (Utenti) nella barra di navigazione per visualizzare gli utenti IAM.
    3.   Se non sono stati configurati utenti IAM, fare clic su Create New Users (Crea nuovi utenti) per crearne
         uno.
    4.   Selezionare l'utente IAM nell'elenco che verrà utilizzato per accedere ad AWS.
    5.   Aprire la scheda Security Credentials (Credenziali di sicurezza) e scegliere Create Access Key (Crea
         chiave di accesso).
             Note

             Puoi avere un massimo di due chiavi di accesso attive per un utente IAM specifico. Se l'utente
             IAM dispone già di due chiavi di accesso, sarà necessario eliminarne una prima di creare una
             nuova chiave.
    6.   Nella finestra di dialogo risultante, fare clic sul pulsante Download Credentials (Scarica credenziali) per
         scaricare il file delle credenziali nel computer o fare clic su Show User Security Credentials (Mostra

                                                     3
SDK AWS per Java Developer Guide
                                         Configurazione dell'SDK

         credenziali di sicurezza utente) per visualizzare l'ID chiave di accesso dell'utente IAM e la chiave di
         accesso segreta (che può essere copiata e incollata).
             Important

             Non esiste modo di ottenere la chiave di accesso segreta una volta chiusa la finestra di
             dialogo. Puoi, tuttavia, eliminare l'ID chiave di accesso associato e crearne una nuova.

    Quindi, impostare le credenziali (p. 5) nel file delle credenziali condivise di AWS o nell'ambiente.

Configurazione di AWS SDK for Java 2.0
(Anteprima per sviluppatori)
    In questo argomento viene descritto come configurare e utilizzare AWS SDK for Java nel progetto.

    Prerequisiti
    Per utilizzare AWS SDK for Java, occorre:

    • Un ambiente di sviluppo Java (p. 5) idoneo.
    • Un account AWS e chiavi di accesso. Per le istruzioni, consulta Registrazione ad AWS e creazione di un
      utente IAM (p. 3).
    • Le credenziali di AWS (chiavi di accesso) impostate nell'ambiente o il file delle credenziali utilizzato da
      AWS CLI e altri SDK. Per ulteriori informazioni, consulta la sezione Configurazione della regione e delle
      credenziali per lo sviluppo di AWS (p. 5).

    Includere l'SDK nel progetto
    A seconda del sistema di creazione o IDE, utilizza uno dei seguenti metodi:

    • Apache Maven- Utilizzando Apache Maven puoi specificare solo i componenti SDK necessari o l'intero
      SDK (scelta non consigliata) come dipendenze nel progetto. Consulta Utilizzo di SDK con Apache
      Maven (p. 7).
    • Gradle - Utilizzando Gradle puoi importare la distinta base Maven nel progetto Gradle per gestire
      automaticamente le dipendenze SDK. Consulta Utilizzo di SDK con Gradle (p. 9).

         Note

         Puoi utilizzare qualsiasi sistema di creazione che supporta MavenCentral come artefatto. Tuttavia,
         non forniremo uno file compresso scaricabile per l'anteprima per sviluppatori.

    Compilazione dell'SDK
    Puoi creare AWS SDK for Java utilizzando Maven. Maven scarica tutte le dipendenze necessarie, crea
    l'SDK e lo installa in un'unica fase. Per le istruzioni di installazione e ulteriori informazioni, visita http://
    maven.apache.org/.

    Per compilare l'SDK

    1.   Aprire SDK AWS per Java 2.0 (GitHub).

                                                        4
SDK AWS per Java Developer Guide
                                Installazione di un ambiente di sviluppo Java

              Note

              In GitHub è anche disponibile la versione 1.0 dell'SDK in SDK AWS per Java 1.x (GitHub).
     2.   Fare clic sul pulsante Clone or download (Clona o scarica) per scegliere l'opzione di download.
     3.   In una finestra del terminale, passare alla directory in cui è stata scaricata l'origine SDK.
     4.   Creare e installare l'SDK utilizzando il seguente comando (Maven obbligatorio).

          mvn clean install

          Il file .jar risultante viene creato nella directory target.
     5.   (Facoltativo) Creare la documentazione di riferimento delle API usando il comando seguente.

          mvn javadoc:javadoc

          La documentazione viene creata nelle directory target/site/apidocs/ di ciascun servizio.

     Installazione di un ambiente di sviluppo Java
     AWS SDK for Java richiede Java SE Development Kit 8.0 o versioni successive. Puoi scaricare la versione
     più recente del software Java da http://www.oracle.com/technetwork/java/javase/downloads/.

     Selezione di una JVM
     Per prestazioni ottimali delle applicazioni basate su server con AWS SDK for Java, ti consigliamo di
     utilizzare la versione a 64 bit di JVM (Java Virtual Machine). Questa JVM viene eseguita solo in modalità
     server, anche se durante il runtime si specifica l'opzione -Client.

Configurazione della regione e delle credenziali per
lo sviluppo di AWS
     Per connettersi a uno qualsiasi dei servizi supportati con AWS SDK for Java, devi fornire le credenziali
     di AWS. Gli SDK AWS e i CLI utilizzano catene di provider per cercare credenziali di AWS in diverse
     ubicazioni, incluse variabili di ambiente dell'utente/del sistema e file di configurazione AWS locali.

     In questo argomento vengono fornite informazioni di base sulla configurazione delle credenziali di AWS
     per lo sviluppo di applicazioni locali utilizzando AWS SDK for Java. Se occorre configurare le credenziali
     per l'utilizzo all'interno di un'istanza Amazon EC2 o se utilizzi l'IDE Eclipse per lo sviluppo, vedi invece i
     seguenti argomenti:

     • Quando utilizzi un'istanza EC2, crea un ruolo IAM e quindi concedi all'istanza EC2 l'accesso a tale ruolo
       come mostrato in Configurazione di ruoli IAM per Amazon EC2 (Avanzate) (p. 25).
     • Configura le credenziali AWS all'interno di Eclipse utilizzando AWS Toolkit for Eclipse. Consulta
       Configurazione delle credenziali di AWS in Guida per l'utente di AWS Toolkit for Eclipse.

     Impostazione delle credenziali di AWS
     Puoi impostare le credenziali per l'utilizzo mediate AWS SDK for Java in diversi modi. Tuttavia, gli approcci
     consigliati sono i seguenti:

                                                       5
SDK AWS per Java Developer Guide
                                Impostazione della regione AWS

• Impostare credenziali nel file del profilo delle credenziali di AWS nel sistema locale, che si trova in:
  • ~/.aws/credentials in Linux, macOS, or Unix
  • C:\Users\USERNAME \.aws\credentials in Windows

  Questo file deve contenere righe nel seguente formato:

  [default]
  aws_access_key_id = your_access_key_id
  aws_secret_access_key = your_secret_access_key

  Sostituire i propri valori delle credenziali di AWS con i valori your_access_key_id e
  your_secret_access_key.
• Impostare le variabili di ambiente AWS_ACCESS_KEY_ID e AWS_SECRET_ACCESS_KEY.

  Per impostare queste variabili in Linux, macOS, or Unix, utilizzare export :

  export AWS_ACCESS_KEY_ID=your_access_key_id
  export AWS_SECRET_ACCESS_KEY=your_secret_access_key

  Per impostare queste variabili in Windows, utilizzare set :

  set AWS_ACCESS_KEY_ID=your_access_key_id
  set AWS_SECRET_ACCESS_KEY=your_secret_access_key

• Per un'istanza di EC2, specificare un ruolo IAM e concedere all'istanza EC2 l'accesso a tale ruolo. Per
  una discussione dettagliata sul funzionamento, consulta Ruoli IAM per Amazon EC2 nella Amazon EC2
  User Guide for Linux Instances.

Una volta impostate le credenziali di AWS utilizzando uno di questi metodi, queste vengono caricate da
AWS SDK for Java automaticamente utilizzando la catena di provider delle credenziali predefinita. Per
ulteriori informazioni sull'utilizzo delle credenziali di AWS nelle applicazioni Java, consulta Utilizzo di
credenziali di AWS (p. 13).

Impostazione della regione AWS
È consigliabile impostare una regione AWS predefinita da utilizzare per accedere ai servizi AWS con AWS
SDK for Java. Per ottimizzare le prestazioni di rete, scegli una regione che è geograficamente vicina a te (o
ai clienti).
    Note

    Se non selezioni una regione, le chiamate del servizio che richiedono una regione non riescono.

Per impostare la regione AWS predefinita, puoi utilizzare tecniche simili a quelle per l'impostazione di
credenziali:

• Impostare la regione AWS nel file di AWS Config sul sistema locale, che si trova in:
  • ~/.aws/config su Linux, macOS, or Unix
  • C:\Users\USERNAME\.aws\config su Windows

  Questo file deve contenere righe nel seguente formato:

  [default]
  region = your_aws_region

                                                 6
SDK AWS per Java Developer Guide
                                    Utilizzo di SDK con Apache Maven

      Sostituire la regione AWS preferita (ad esempio "us-west-2") in your_aws_region.
    • Imposta la variabile di ambiente AWS_REGION.

      In Linux, macOS, or Unix utilizza export :

      export AWS_REGION=your_aws_region

      In Windows, utilizza set :

      set AWS_REGION=your_aws_region

      Dove your_aws_region è il nome della regione AWS desiderato.

    Per informazioni sulla selezione di una regione, consulta Selezione di regioni AWS (p. 17).

Utilizzo di SDK con Apache Maven
    Puoi utilizzare Apache Maven per configurare e creare progetti AWS SDK for Java o creare l'SDK stesso.
        Note

        Per utilizzare le linee guida in questo argomento è necessario che sia installato Maven. Se non è
        già installato, visita http://maven.apache.org/ per scaricarlo e installarlo.

    Creazione di un nuovo pacchetto Maven
    Per creare un pacchetto Maven di base, apri una finestra del terminale (riga di comando) ed esegui quanto
    segue.

    mvn -B archetype:generate \
      -DarchetypeGroupId=org.apache.maven.archetypes \
      -DgroupId=org.example.basicapp \
      -DartifactId=myapp

    Sostituisci org.example.basicapp con lo spazio dei nomi del pacchetto completo dell'applicazione.
    Sostituisci myapp con il nome del progetto (questo diventa il nome della directory del progetto).

    Per impostazione predefinita, Maven crea un modello di progetto per l'utente utilizzando l'archetipo
    quickstart. In questo modo viene creato un progetto Java 1.5. Per la compatibilità con AWS SDK for Java
    2.0, occorre aggiornare l'applicazione a Java 1.8. Per aggiornare a Java 1.8, aggiungi quanto segue al file
    pom.xml.

          org.apache.maven.plugins
          maven-compiler-plugin
          
             1.8
             1.8
          
                                                   7
SDK AWS per Java Developer Guide
                       Configurazione di SDK come una dipendenza Maven

Può scegliere un determinato archetipo da utilizzare aggiungendo l'argomento -DarchetypeArtifactId
al comando archetype:generate. Per ignorare la fase di aggiornamento del file pom.xml, puoi
utilizzare il seguente archetipo che consente di creare un progetto Java 1.8 dall'inizio.

mvn archetype:generate -B \
   -DarchetypeGroupId=pl.org.miki \
   -DarchetypeArtifactId=java8-quickstart-archetype \
   -DarchetypeVersion=1.0.0 \
   -DgroupId=com.example \
   -DartifactId=sdk-sandbox \
   -Dversion=1.0 \
   -Dpackage=com.example

Sono disponibili altri archetipi. Per un elenco degli archetipi forniti nel pacchetto di Maven, consulta
Archetipi Maven.
    Note

    Per ulteriori informazioni sulla creazione e la configurazione di progetti Maven, consulta la Guida
    alle operazioni di base Maven.

Configurazione di SDK come una dipendenza Maven
Per utilizzare AWS SDK for Java nel progetto, occorre dichiararla come una dipendenza nel file pom.xml
del progetto. Puoi importare singoli componenti (p. 8) o l'intero SDK (p. 9). Ti consigliamo di
inserire solo i componenti necessari anziché tutto l'SDK.

Specifica di moduli SDK singoli (scelta consigliata)
Per selezionare moduli SDK singoli, utilizza la distinta base AWS SDK for Java per Maven. In questo modo,
i moduli specificati utilizzano la stessa versione dell'SDK e sono tra loro compatibili.

Per utilizzare la distinta base, aggiungi una sezione  al file pom.xml
dell'applicazione. Aggiungi bom come una dipendenza e specifica la versione dell'SDK da utilizzare.

      software.amazon.awssdk
      bom
      2.0.0
      pom
      import
    
Se stai testando l'anteprima per sviluppatori, aggiungi preview-* alla versione.
    Note

    Non è possibile utilizzare una combinazione dell'anteprima per sviluppatori AWS SDK for Java 2.0
    e di moduli non in anteprima in un solo progetto.

                                                 8
SDK AWS per Java Developer Guide
                                        Creazione del progetto

           software.amazon.awssdk
           bom
           2.0.0-preview-10
           pom
           import
         
     Per visualizzare la versione più recente della distinta base di AWS SDK for Java disponibile su Maven
     Central, visita https://mvnrepository.com/artifact/software.amazon.awssdk/bom. In questa pagina vengono
     anche mostrati i moduli (dipendenze) che sono gestiti dalla distinta base che puoi includere all'interno della
     sezione  del file pom.xml del progetto.

     Ora puoi selezionare singoli moduli dall'SDK che utilizzi nell'applicazione. Poiché la versione SDK è già
     stata dichiarata nella distinta base, non è necessario specificare il numero di versione di ogni componente.

         software.amazon.awssdk
         kinesis
       
         software.amazon.awssdk
         dynamodb
       
     Importazione di tutti i moduli SDK (scelta non consigliata)
     Per ottenere l'intero SDK come una dipendenza, non utilizzare il metodo della distinta base. Dichiaralo
     semplicemente in pom.xml come segue.

         software.amazon.awssdk
         aws-java-sdk
         2.0.0
       
     Creazione del progetto
     Una volta configurato, puoi creare il progetto utilizzando il comando package di Maven.

     mvn package

     Questo consente di creare il file .jar nella directory target.

Utilizzo di SDK con Gradle
     Per utilizzare AWS SDK for Java nel progetto Gradle, utilizza il plug-in di gestione delle dipendenze di
     Spring per Gradle. Puoi utilizzare questo plug-in per importare la distinta base Maven di SDK per gestire
     dipendenze SDK per il progetto.

                                                     9
SDK AWS per Java Developer Guide
                                  Utilizzo di SDK con Gradle

Per configurare l'SDK per Gradle

1.   Aggiungere il plug-in di gestione delle dipendenze per il file build.gradle.

     buildscript {
         repositories {
             mavenCentral()
         }
         dependencies {
             classpath "io.spring.gradle:dependency-management-plugin:1.0.3.RELEASE"
         }
     }

     apply plugin: "io.spring.dependency-management"

2.   Aggiungere la distinta base alla sezione dependencyManagement del file.

     dependencyManagement {
         imports {
             mavenBom 'software.amazon.awssdk:bom:2.0.0'
         }
     }

     Se stai testando l'anteprima per sviluppatori, aggiungi preview-* alla versione.
         Note

         Non è possibile utilizzare una combinazione dell'anteprima per sviluppatori AWS SDK for Java
         2.0 e di moduli non in anteprima in un solo progetto.

     dependencyManagement {
         imports {
             mavenBom 'software.amazon.awssdk:bom:2.0.0-preview-10'
         }
     }

3.   Specificare i moduli SDK da utilizzare nella sezione dipendenze.

     dependencies {
         compile 'software.amazon.awssdk:kinesis'
         testCompile group: 'junit', name: 'junit', version: '4.11'
     }

Gradle risolve automaticamente la versione corretta delle dipendenze SDK utilizzando le informazioni della
distinta base.

Di seguito è riportato il file build.gradle completo:

group 'aws.test'
version '1.0'

apply plugin: 'java'

sourceCompatibility = 1.8

repositories {
  mavenCentral()
}

buildscript {

                                               10
SDK AWS per Java Developer Guide
                                  Utilizzo di SDK con Gradle

    repositories {
        mavenCentral()
    }
    dependencies {
        classpath "io.spring.gradle:dependency-management-plugin:1.0.3.RELEASE"
    }
}

apply plugin: "io.spring.dependency-management"

dependencyManagement {
  imports {
      mavenBom 'software.amazon.awssdk:bom:2.0.0'
  }
}

dependencies {
  compile 'software.amazon.awssdk:kinesis'
  testCompile group: 'junit', name: 'junit', version: '4.11'
}

     Note

     Per ulteriori informazioni su come specificare dipendenze SDK utilizzando la distinta base,
     consulta Utilizzo di SDK con Apache Maven (p. 7).

                                               11
SDK AWS per Java Developer Guide
                                     Creazione di client del servizio

Utilizzo di AWS SDK for Java 2.0
(Anteprima per sviluppatori)
     In questa sezione vengono fornite informazioni generali importanti sulla programmazione con AWS SDK for
     Java che si applicano a tutti i servizi che puoi utilizzare con l'SDK.

     Argomenti
      • Creazione di client del servizio (p. 12)
      • Utilizzo di credenziali di AWS (p. 13)
      • Selezione di regioni AWS (p. 17)
      • Programmazione asincrona (p. 19)
      • Programmazione HTTP/2 (p. 21)
      • Gestione delle eccezioni (p. 21)
      • Registrazione delle chiamate di AWS SDK for Java (p. 22)
      • Configurazione di ruoli IAM per Amazon EC2 (Avanzate) (p. 25)

Creazione di client del servizio
     Per effettuare richieste ad Amazon Web Services, occorre prima creare un oggetto client del servizio. Nella
     versione 2.0 dell'SDK, puoi creare client solo utilizzando i generatori dei client del servizio.

     Ogni servizio AWS dispone dell'interfaccia del servizio con metodi per ciascuna operazione nell'API del
     servizio. Ad esempio, l'interfaccia del servizio per Amazon DynamoDB è denominata DynamoDbClient.
     Ogni interfaccia del servizio dispone di un metodo del generatore di factory statico che puoi utilizzare per
     costruire un'implementazione dell'interfaccia del servizio.

     Ottenere un generatore client
     Per ottenere un'istanza di client, utilizza il metodo factory statico builder. Quindi personalizzalo
     utilizzando i setter nel generatore, come mostrato nell'esempio seguente.

     In AWS SDK for Java 2.0, i setter sono denominati senza il prefisso with.

     DynamoDBClient client = DynamoDBClient.builder()
                             .region(Region.US_WEST_2)
                             .credentialsProvider(ProfileCredentialsProvider.builder()
                                          .profileName("myProfile")
                                          .build())
                             .build();

         Note

         I metodi setter fluent restituiscono l'oggetto builder. In questo modo puoi concatenare chiamate
         al metodo per comodità e per avere un codice più leggibile. Dopo aver configurato le proprietà
         desiderate, puoi chiamare il metodo build per creare il client. Dopo che è stato creato, il client

                                                     12
SDK AWS per Java Developer Guide
                                         Utilizzo di DefaultClient

         non è più modificabile. Il solo modo per creare un client con impostazioni diverse è quello di creare
         un nuovo client.

     Utilizzo di DefaultClient
     I generatori client dispongono di un altro metodo factory denominato create. Questo metodo consente
     di creare un client del servizio con la configurazione predefinita. Utilizza la catena di provider predefinita
     per caricare le credenziali e la regione AWS. Se non è possibile determinare le credenziali o la regione
     dall'ambiente di esecuzione dell'applicazione, la chiamata a create non riesce. Per ulteriori informazioni
     su come credenziali e regione sono determinati, consulta Utilizzo di credenziali AWS (p. 13) e Selezione
     di regioni AWS (p. 17).

     Per creare un client predefinito
     DynamoDBClient client = DynamoDBClient.create();

     Ciclo di vita del client
     I client del servizio nell'SDK sono thread-safe. Per prestazioni ottimali, ti consigliamo di trattarli come
     oggetti di lunga durata. Ogni client dispone di una propria risorsa di pooling delle connessioni che viene
     rilasciata durante il processo di garbage collection del client. I client in AWS SDK for Java 2.0 estendono
     ora l'interfaccia AutoClosable. Per le best practice, chiudere in maniera esplicita un client chiamando il
     metodo close.

     Per chiudere un client
     DynamoDBClient client = DynamoDBClient.create();
     client.close();

Utilizzo di credenziali di AWS
     Per effettuare richieste ad Amazon Web Services, occorre fornire credenziali di AWS ad AWS SDK for
     Java. Questa operazione può essere eseguita nei modi seguenti:

     • Utilizzando la catena di provider delle credenziali predefinita (scelta consigliata).
     • Utilizzando un provider di credenziali o catena di provider specifica (o creando la propria).
     • Fornendo tu stesso le credenziali. Queste possono essere credenziali dell'account AWS, credenziali IAM
       o credenziali temporanee recuperate da AWS STS.

         Important

         Per motivi di sicurezza, ti consigliamo di utilizzare le credenziali dell'account IAM anziché le
         credenziali dell'account AWS per l'accesso AWS. Per ulteriori informazioni, consulta Credenziali di
         sicurezza di AWS nella Amazon Web Services General Reference.

     Utilizzo della catena di provider delle credenziali
     predefinita
     Quando si inizializza un nuovo servizio client senza fornire argomenti, AWS SDK for Java tenta di trovare le
     credenziali di AWS utilizzando la catena di provider delle credenziali predefinita implementata dalla classe

                                                     13
SDK AWS per Java Developer Guide
                    Utilizzo della catena di provider delle credenziali predefinita

DefaultCredentialsProvider. La catena di provider delle credenziali predefinita cerca le credenziali in questo
ordine:

1. Proprietà del sistema Java - aws.accessKeyId e aws.secretAccessKey. AWS SDK for Java
   utilizza SystemPropertyCredentialsProvider per caricare tali credenziali.
2. Variabili di ambiente: AWS_ACCESS_KEY_ID e AWS_SECRET_ACCESS_KEY. AWS SDK for Java utilizza
   la classe EnvironmentVariableCredentialsProvider per caricare tali credenziali.
3. Il file dei profili delle credenziali predefinito - Si trova in genere in ~/.aws/credentials (posizione che
   può variare con la piattaforma) ed è condiviso da molti degli SDK AWS e da AWS CLI. AWS SDK for
   Java utilizza ProfileCredentialsProvider per caricare queste credenziali.

  Puoi creare un file delle credenziali utilizzando il comando aws configure fornito da AWS CLI oppure
  modificando il file con un editor di testo. Per informazioni sul formato del file delle credenziali, consulta
  Formato del file delle credenziali di AWS (p. 15).
4. Credenziali del container Amazon ECS - Vengono caricate da Amazon ECS se è impostata la variabile
   di ambiente AWS_CONTAINER_CREDENTIALS_RELATIVE_URI. AWS SDK for Java utilizza l'oggetto
   ContainerCredentialsProvider per caricare queste credenziali.
5. Credenziali del profilo dell'istanza - Vengono utilizzate su istanze Amazon EC2 e
   distribuite tramite il servizio di metadati Amazon EC2. AWS SDK for Java utilizza l'oggetto
   InstanceProfileCredentialsProvider per caricare queste credenziali.

Impostazione delle credenziali
Per poter essere utilizzate, le credenziali di AWS devono essere impostate in almeno una delle posizioni
precedenti. Per informazioni sull'impostazione delle credenziali, consulta i seguenti argomenti:

• Per specificare credenziali nell'ambiente o nel file dei profili delle credenziali predefinito, consulta
  Configurazione della regione e delle credenziali per lo sviluppo di AWS (p. 5).
• Per impostare proprietà del sistema Java, consulta il tutorial sulle proprietà del sistema nel sito Web dei
  tutorial Java ufficiale.
• Per impostare e utilizzare le credenziali del profilo di istanza con le istanze EC2, consulta Configurazione
  di ruoli IAM per Amazon EC2 (Avanzate) (p. 25).

Impostazione di un profilo delle credenziali alternativo
AWS SDK for Java utilizza il profilo predefinito per default, ma ci sono modi per personalizzare quale profilo
viene restituito dal file delle credenziali.

Puoi utilizzare la variabile di ambiente AWS_PROFILE per modificare il profilo caricato da SDK.

Ad esempio, in Linux, macOS, or Unix, esegui il comando seguente per modificare il profilo in myProfile.

export AWS_PROFILE="myProfile"

In Windows, utilizza il seguente formato:

set AWS_PROFILE="myProfile"

L'impostazione della variabile di ambiente AWS_PROFILE influenza il caricamento delle credenziali per tutti
gli SDK e gli strumenti AWS supportati ufficialmente (inclusi AWS CLI e AWS CLI per PowerShell). Per
modificare solo il profilo per un'applicazione Java, puoi utilizzare invece la proprietà di sistema aws.profile.

                                                  14
SDK AWS per Java Developer Guide
                   Utilizzo della catena di provider delle credenziali predefinita

Impostazione di un percorso del file delle credenziali alternativo
AWS SDK for Java carica automaticamente le credenziali di AWS dal percorso del file delle
credenziali predefinito. Tuttavia, puoi anche specificare il percorso impostando la variabile di ambiente
AWS_CREDENTIAL_PROFILES_FILE con il percorso completo al file delle credenziali.

Puoi utilizzare questa caratteristica per modificare temporaneamente il percorso in cui AWS SDK for Java
esegue la ricerca delle credenziali (ad esempio, impostando questa variabile con la riga di comando). In
alternativa, puoi impostare la variabile di ambiente nell'ambiente utente o di sistema per modificarla a livello
di utente o di sistema.

Per ignorare il percorso del file delle credenziali predefinito
• Imposta la variabile di ambiente AWS_CREDENTIAL_PROFILES_FILE sul percorso del file delle
  credenziali di AWS.
  • In Linux, macOS, or Unix utilizza export :

    export AWS_CREDENTIAL_PROFILES_FILE=path/to/credentials_file

  • In Windows, utilizza set :

    set AWS_CREDENTIAL_PROFILES_FILE=path/to/credentials_file

Formato del file delle credenziali di AWS
Quando utilizzi il comando aws configure per creare un file delle credenziali di AWS, viene creato un file
con il seguente formato.

[default]
aws_access_key_id={YOUR_ACCESS_KEY_ID}
aws_secret_access_key={YOUR_SECRET_ACCESS_KEY}

[profile2]
aws_access_key_id={YOUR_ACCESS_KEY_ID}
aws_secret_access_key={YOUR_SECRET_ACCESS_KEY}

Il nome del profilo è specificato tra parentesi quadre (ad esempio, [default]), seguito dai campi
configurabili nel profilo come coppie chiave-valore. Il file delle credenziali può contenere più profili che
possono essere aggiunti o modificati utilizzando aws configure --profile PROFILE_NAME per
selezionare il profilo da configurare. Oltre alla chiave di accesso e alle chiavi di accesso segrete, puoi
specificare un token di sessione utilizzando il campo aws_session_token.

Caricamento di credenziali
Dopo che sono state impostate, puoi caricare le credenziali utilizzando la catena di provider delle
credenziali predefinita.

A questo scopo, puoi creare un'istanza di un client del servizio AWS senza fornire in maniera esplicita
credenziali al generatore, come descritto di seguito.

S3Client s3 = S3Client.builder()
                       .region(Region.US_WEST_2)
                       .build();

                                                 15
SDK AWS per Java Developer Guide
                   Specifica di un provider delle credenziali o catena di provider

Specifica di un provider delle credenziali o catena di
provider
Puoi specificare un provider delle credenziali diverso dalla catena di provider delle credenziali predefinita
utilizzando il generatore client.

Devi fornire un'istanza di un provider delle credenziali o catena di provider a un generatore client che
accetta un'interfaccia AwsCredentialsProvider come input. Nell'esempio seguente viene mostrato come
utilizzare specificatamente le credenziali ambiente.

S3Client s3 = S3Client.builder()

 .credentialsProvider(EnvironmentVariableCredentialsProvider.create())
                       .build();

Per l'elenco completo di provider delle credenziali e catene di provider forniti da AWS SDK for Java,
consulta la sezione relativa a tutte le classi di implementazione note in AwsCredentialsProvider.
     Note

     Puoi utilizzare questa tecnica per fornire provider delle credenziali o catene di provider
     create utilizzando il tuoi provider delle credenziali che implementa l'interfaccia
     AwsCredentialsProvider.

Specifica in maniera esplicita delle credenziali
Se la catena di credenziali predefinita o un provider specifico o personalizzato o una catena di provider non
funziona con il codice, puoi impostare credenziali fornite in maniera esplicita. Se hai recuperato credenziali
temporanee utilizzando AWS STS, utilizza questo metodo per specificare le credenziali per l'accesso AWS.

Per fornire credenziali a un client AWS in maniera esplicita

1.   Creare un'istanza di una classe che fornisce l'interfaccia AwsCredentials, ad esempio
     AwsSessionCredentials. Fornirla con la chiave di accesso AWS e la chiave segreta che verranno
     utilizzate per la connessione.
2.   Creare un StaticCredentialsProvider con l'oggetto AwsCredentials.
3.   Configurare il generatore client con StaticCredentialsProvider e creare il client.

Di seguito è riportato un esempio.

AwsSessionCredentials awsCreds = AwsSessionCredentials.create(
      "access_key_id",
      "secret_key_id",
      "session_token");
S3Client s32 = S3Client.builder()
                       .credentialsProvider(StaticCredentialsProvider.create(awsCreds))
                       .build();

Ulteriori informazioni
• Registrazione ad AWS e creazione di un utente IAM (p. 3)
• Configurazione della regione e delle credenziali per lo sviluppo di AWS (p. 5)

                                                 16
SDK AWS per Java Developer Guide
                                       Selezione di regioni AWS

    • Configurazione di ruoli IAM per Amazon EC2 (Avanzate) (p. 25)

Selezione di regioni AWS
    Le regioni consentono di accedere ai servizi AWS che risiedono fisicamente in un'area geografica specifica.
    Ciò può essere utile per la ridondanza e per mantenere i dati e le applicazioni in esecuzione vicino ai punti
    di accesso ai servizi stessi.

    In AWS SDK for Java 2.0, tutte le diverse classi correlate alla regione della versione 1.x sono state
    compresse in un'unica classe Region. Puoi utilizzare questa classe per tutte le operazioni correlate alla
    regione, ad esempio il recupero dei metadati relativi a una regione o la verifica della disponibilità di un
    servizio in una regione.

    Scelta di una regione
    Se specifichi un nome della regione, l'SDK sceglierà automaticamente un endpoint appropriato.

    Per impostare in maniera esplicita una regione, ti consigliamo di utilizzare le costanti definite nella classe
    Region. Si tratta di un'enumerazione di tutte le regioni disponibili pubblicamente. Per creare un client con
    una regione dalla classe, utilizza il codice seguente.

    EC2Client ec2 = EC2Client.builder()
                        .region(Region.US_WEST_2)
                        .build();

    Se la regione che stai tentando di utilizzare non è una delle costanti nella classe Region, puoi creare una
    nuova regione utilizzando il metodo of. Questa caratteristica consente di accedere a nuove regioni senza
    aggiornare l'SDK.

    Region newRegion = Region.of("us-east-42");
    EC2Client ec2 = EC2Client.builder()
                        .region(newRegion)
                        .build();

        Note

        Dopo che è stato creato con il generatore, il client è immutabile e la regione non può essere
        modificata. Se utilizzi più regioni AWS per lo stesso servizio, devi creare più client, uno per
        regione.

    Scelta di un endpoint specifico
    Ogni client AWS può essere configurato per utilizzare un endpoint specifico all'interno di una regione
    chiamando il metodo endpointOverride.

    Ad esempio, per configurare il client Amazon EC2 per utilizzare UE (Irlanda), utilizza il codice seguente.

    EC2Client ec2 = EC2Client.builder()
                                 .region(Region.EU_WEST_1)
                                 .endpointOverride(URI.create("https://ec2.eu-
    west-1.amazonaws.com"))
                                 .build();

                                                     17
SDK AWS per Java Developer Guide
                   Determinazione automatica della regione AWS dall'ambiente

Per l'elenco corrente di regioni e gli endpoint corrispondenti per tutti i servizi AWS, consulta Regioni ed
endpoint.

Determinazione automatica della regione AWS
dall'ambiente
Durante l'esecuzione su Amazon EC2 o AWS Lambda, potrebbe essere necessario configurare i client
per utilizzare la stessa regione su cui è in esecuzione il codice. Questo consente di separare il codice
dall'ambiente in cui è in esecuzione e facilita la distribuzione dell'applicazione in più regioni per minore
latenza o ridondanza.

Per utilizzare la catena di provider delle credenziali/regioni predefinita per determinare la regione
dell'ambiente, utilizza il metodo create del generatore client.

EC2Client ec2 = EC2Client.create();

Se una regione non viene impostata in maniera esplicita utilizzando il metodo region, l'SDK consulta la
catena di provider delle regioni predefinita per provare a determinare la regione da utilizzare.

Catena di provider delle regioni predefinita
Di seguito è riportato il processo di ricerca della regione:

1. Qualsiasi regione esplicita impostata utilizzando region sul generatore stesso ha la precedenza su
   tutto il resto.
2. La variabile di ambiente AWS_REGION è selezionata. Se è impostata, questa regione viene utilizzata per
   configurare il client.
       Note
        Questa variabile di ambiente è impostata dal container Lambda.
3. L'SDK controlla il file di configurazione condiviso AWS (che si trova in genere in ~/.aws/config). Se la
   proprietà region è presente, viene utilizzata dall'SDK.
   • La variabile di ambiente AWS_CONFIG_FILE può essere utilizzata per personalizzare il percorso del
     file di configurazione condiviso.
   • La variabile di ambiente AWS_PROFILE o la proprietà di sistema aws.profile può essere utilizzata per
     personalizzare il profilo caricato da SDK.
4. L'SDK tenta di utilizzare il servizio di metadati dell'istanza Amazon EC2 per determinare la regione
   dell'istanza Amazon EC2 attualmente in esecuzione.
5. Se a questo punto l'SDK non ha ancora trovato una regione, la creazione del client non riesce con
   un'eccezione.

Durante lo sviluppo di applicazioni AWS, un approccio comune è utilizzare il file di configurazione condiviso
(descritto in Utilizzo della catena di provider delle credenziali predefinita (p. 13)) per impostare la regione
per lo sviluppo locale e basarsi sulla catena di provider delle regioni predefinita per determinare la regione
durante l'esecuzione su un'infrastruttura AWS. Questo semplifica notevolmente la creazione del client e
mantiene l'applicazione portatile.

Verifica della disponibilità del servizio in una regione
AWS
Per vedere se un particolare servizio AWS è disponibile in una regione, utilizza il metodo
serviceMetadata e region sul servizio da controllare.

                                                 18
SDK AWS per Java Developer Guide
                                     Programmazione asincrona

    DynamoDBClient.serviceMetadata().regions().forEach(System.out::println);

    Consulta la documentazione della classe Region per le regioni che puoi specificare e utilizza il prefisso
    endpoint del servizio di cui eseguire la query.

Programmazione asincrona
    AWS SDK for Java 2.0 è dotato di client asincroni senza blocchi che consente di implementare alta
    simultaneità tra alcuni thread. AWS SDK for Java 1.11.x dispone di client asincroni che sono dei wrapper
    attorno a un pool di thread e client sincroni con blocchi che non forniscono il vantaggio completo dell'I/O
    senza blocchi.

    I metodi sincroni bloccano l'esecuzione del thread finché il client non riceve una risposta dal servizio. I
    metodi asincroni terminano immediatamente, riassegnando il controllo al thread chiamante senza attendere
    una risposta.

    Poiché un metodo asincrono termina prima che sia disponibile una risposta, occorre un modo per ottenere
    la risposta quando è pronta. I metodi del client asincrono di AWS SDK for Java 2.0 restituiscono oggetti
    CompletableFuture che consentono di accedere alla risposta quando è pronta.

    Operazioni non di streaming
    Per le operazioni non di streaming, le chiamate al metodo asincrono sono simili ai metodi sincroni tranne
    che i metodi asincroni in AWS SDK for Java restituiscono un oggetto CompletableFuture contenente i
    risultati dell'operazione asincrona nel futuro.

    Chiama il metodo CompletableFuture whenComplete() con un'azione da completare quando il
    risultato è disponibile. CompletableFuture implementa l'interfaccia Future in modo da ottenere
    l'oggetto di risposta chiamando il metodo get().

    Di seguito è riportato un esempio di un'operazione asincrona che chiama una funzione DynamoDB
    per ottenere un elenco di tabelle, ricevendo un CompletableFuture che può contenere un oggetto
    ListTablesResponse. L'azione definita nella chiamata a whenComplete() viene eseguita solo al termine
    della chiamata asincrona.

    import java.util.concurrent.CompletableFuture;

    public class DynamoDBAsync {

        public static void main(String[] args) throws InterruptedException {
            // Creates a default async client with credentials and regions loaded from the
     environment
            DynamoDbAsyncClient client = DynamoDbAsyncClient.create();
            CompletableFuture response =
     client.listTables(ListTablesRequest.builder()

     .build());

            // Map the response to another CompletableFuture containing just the table names
            CompletableFuture tableNames =
     response.thenApply(ListTablesResponse::tableNames);
            // When future is complete (either successfully or in error) handle the response
            tableNames.whenComplete((tables, err) -> {
                try {
                 if (tables != null) {
                        tables.forEach(System.out::println);
                    } else {

                                                   19
SDK AWS per Java Developer Guide
                                  Operazioni di streaming

                       // Handle error
                       err.printStackTrace();
                }
            } finally {
                // Lets the application shut down. Only close the client when you are
 completely done with it.
                client.close();
            }
        });

         tableNames.join();
    }
}

Operazioni di streaming
Per le operazioni di streaming, occorre passare un oggetto AsyncRequestBody per fornire i contenuti in
modo incrementale o un oggetto AsyncResponseTransformer per ricevere ed elaborare la risposta.

Di seguito è riportato un esempio che carica un file in Amazon S3 in modo asincrono con l'operazione
PutObject.

public class S3AsyncOps {

    private static final String BUCKET = "sample-bucket";
 private static final String KEY = "testfile.in";

 public static void main(String[] args) {
     S3AsyncClient client = S3AsyncClient.create();
        CompletableFuture future = client.putObject(
                PutObjectRequest.builder()
                                .bucket(BUCKET)
                                .key(KEY)
                                .build(),
                AsyncRequestBody.fromFile(Paths.get("myfile.in"))
        );
        future.whenComplete((resp, err) -> {
            try {
                if (resp != null) {
                    System.out.println("my response: " + resp);
                } else {
                    // Handle error
                    err.printStackTrace();
                }
            } finally {
                // Lets the application shut down. Only close the client when you are
 completely done with it.
                client.close();
            }
        });

         future.join();
    }
}

Di seguito è riportato un esempio che recupera un file da Amazon S3 in modo asincrono con l'operazione
GetObject.

public class S3AsyncStreamOps {

    private static final String BUCKET = "sample-bucket";

                                              20
SDK AWS per Java Developer Guide
                                        Programmazione HTTP/2

      private static final String KEY = "testfile.out";

      public static void main(String[] args) {
          S3AsyncClient client = S3AsyncClient.create();
           final CompletableFuture futureGet = client.getObject(
                     GetObjectRequest.builder()
                                     .bucket(BUCKET)
                                     .key(KEY)
                                     .build(),
                     AsyncResponseTransformer.toFile(Paths.get("myfile.out")));
           futureGet.whenComplete((resp, err) -> {
                 try {
                     if (resp != null) {
                         System.out.println(resp);
                     } else {
                         // Handle error
                         err.printStackTrace();
                     }
                 } finally {
                     // Lets the application shut down. Only close the client when you are
      completely done with it
                     client.close();
                 }
             });

              futureGet.join();
          }
     }

Programmazione HTTP/2
     HTTP/2 è una revisione principale del protocollo HTTP. Questa nuova versione presenta diversi
     miglioramenti per aumentare le prestazioni:

     • La codifica dei dati binari offre un trasferimento dei dati più efficace.
     • La compressione delle intestazioni riduce i byte in eccesso scaricati dal client, in modo che ottenga i
       contenuti in modo più rapido. Questo è particolarmente utile per i client mobili che sono già vincolati dalla
       larghezza di banda.
     • La comunicazione bidirezionale asincrona (multiplexing) consente a più messaggi di richiesta e di
       risposta tra il client e AWS di essere in transito nello stesso momento su un'unica connessione, anziché
       su più connessioni, migliorando così le prestazioni.

     Gli sviluppatori che eseguono l'upgrade agli ultimi SDK utilizzano automaticamente HTTP/2, se il servizio
     con cui lavorano lo supporta. Le nuove interfacce di programmazione sfruttano in modo ottimale le
     caratteristiche di HTTP/2 e offrono nuovi modi per creare applicazioni.

     AWS SDK for Java 2.0 presenta nuove API per lo streaming di eventi in grado di implementare il protocollo
     HTTP/2. Per esempi dell'utilizzo di queste nuove API, consulta Esempi dell'utilizzo di SDK AWS per Java in
     Kinesis (p. 83).

Gestione delle eccezioni
     Comprendere come e quando AWS SDK for Java genera eccezioni è importante per la creazione di
     applicazioni di alta qualità utilizzando l'SDK. Nelle seguenti sezioni vengono descritti i diversi casi di
     eccezioni che vengono generate dall'SDK e come gestirle in modo appropriato.

                                                       21
Puoi anche leggere