SDK AWS per Java Developer Guide - SDK AWS per Java: Developer Guide - Amazon.com
←
→
Trascrizione del contenuto della pagina
Se il tuo browser non visualizza correttamente la pagina, ti preghiamo di leggere il contenuto della pagina quaggiù
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
iiiSDK 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
ivSDK 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:
1SDK 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.
2SDK 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
3SDK 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).
4SDK 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:
5SDK 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
6SDK 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
7SDK 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.
8SDK 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.
9SDK 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 {
10SDK 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).
11SDK 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
12SDK 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
13SDK 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.
14SDK 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();
15SDK 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)
16SDK 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();
17SDK 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.
18SDK 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 {
19SDK 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";
20SDK 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.
21Puoi anche leggere
