AWS Toolkit for Eclipse - Guida per l'utente - AWS Toolkit for Eclipse: Guida per l'utente - 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ù
AWS Toolkit for Eclipse
Guida per l'utente
AWS Toolkit for Eclipse: Guida per l'utente
Copyright © Amazon Web Services, Inc. and/or its affiliates. All rights reserved.
AWS Toolkit for Eclipse Guida per l'utente I marchi e il trade dress di Amazon non possono essere utilizzati in relazione a prodotti o servizi che non siano di Amazon, in qualsiasi modo che possa causare confusione tra i clienti o in qualsiasi modo che denigri o discrediti Amazon. Tutti gli altri marchi non di proprietà di Amazon sono di proprietà delle rispettive aziende, che possono o meno essere associate, collegate o sponsorizzate da Amazon.
AWS Toolkit for Eclipse Guida per l'utente
Table of Contents
Che cos'è ?AWSToolkit for Eclipse? ...................................................................................................... 1
Documentazione e risorse aggiuntive ............................................................................................. 1
Nozioni di base .................................................................................................................................. 2
Impostazione del Toolkit .............................................................................................................. 2
Prerequisites ...................................................................................................................... 2
Installa il Toolkit for Eclipse .................................................................................................. 2
Aggiornamento del Toolkit for Eclipse .................................................................................... 3
ConfigurazioneAWSCredenziali ..................................................................................................... 3
Ottenimento delle chiavi di accesso AWS ............................................................................... 3
Aggiungi il tuoAWSchiavi di accesso al Toolkit for Eclipse ......................................................... 4
Utilizzo di piùAWSaccount con il Toolkit for Eclipse .................................................................. 5
Modifica dellaAWSPosizione del file delle credenziali ............................................................... 6
Associazione delle chiavi private alle coppie di chiavi Amazon EC2 .................................................... 6
Elemento fondamentali di Toolkit for Eclipse ........................................................................................... 8
In fase di creazioneAWSApplicazione Java ..................................................................................... 8
Crea ed esegui l'esempio Amazon Simple Queue Service ......................................................... 8
Progetti serverless .................................................................................................................... 10
Creazione di un progetto serverless ..................................................................................... 10
Piani di progetto serverless ................................................................................................ 12
Struttura di progetto serverless ........................................................................................... 12
Distribuzione di un progetto serverless ................................................................................. 12
Vedi anche ...................................................................................................................... 13
DifferenziazioneAWSRisorse con denominazione .......................................................................... 14
Utilizzo di servizi AWS ....................................................................................................................... 18
Come accedere a .AWSEsploratore ............................................................................................. 18
Utilizzo di Lambda con il Toolkit for Eclipse .................................................................................. 20
Tutorial: Come creare, caricare e richiamare unAWS LambdaFunzione ...................................... 21
AWS LambdaDocumentazione di riferimento per l'interfaccia di ................................................ 30
LaAWS CloudFormationeditor di modelli ....................................................................................... 37
Aggiunta e accessoAWS CloudFormationModelli in Eclipse ..................................................... 38
Distribuzione di unAWS CloudFormationEclipse ..................................................................... 40
Aggiornamento di unAWS CloudFormationEclipse .................................................................. 43
Convalida di unAWS CloudFormationEclipse ......................................................................... 45
Utilizzo di DynamoDB conAWSEsploratore ................................................................................... 46
Creazione di una tabella DynamoDB ................................................................................... 46
Visualizzazione di una tabella DynamoDB come una griglia ..................................................... 47
Modifica di attributi e valori ................................................................................................. 48
Scansione di una tabella DynamoDB ................................................................................... 49
Avvio di un'istanza Amazon EC2 ................................................................................................. 50
Gestione dei gruppi di sicurezzaAWSEsploratore ........................................................................... 54
Creazione di un nuovo gruppo di sicurezza ........................................................................... 54
Aggiunta di autorizzazioni ai gruppi di sicurezza .................................................................... 55
Visualizzazione e aggiunta delle notifiche Amazon SNS ................................................................. 57
Visualizza una notifica Amazon SNS ................................................................................... 57
Aggiunta di una notifica Amazon SNS .................................................................................. 58
Connessione a Amazon Relational Database Service (Amazon RDS) ................................................ 59
Identity and Access Management ................................................................................................ 61
Informazioni su AWS Identity and Access Management .......................................................... 61
Creare un utente IAM ........................................................................................................ 62
Creazione di un gruppo IAM ............................................................................................... 63
Aggiunta di un utente IAM a un gruppo IAM ......................................................................... 64
Gestione delle credenziali per un utente IAM ........................................................................ 65
Creare un ruolo IAM ......................................................................................................... 69
Collegamento di una policy IAM a un utente, un gruppo o un ruolo ........................................... 72
iii
AWS Toolkit for Eclipse Guida per l'utente
Impostazione della policy sulle password .............................................................................. 75
Eseguire il debug di applicazioni serverless tramiteAWSSAM local ................................................... 76
Prerequisites ...................................................................................................................... 2
Importare l'applicazione SAM da AWS CodeStar ................................................................... 77
Esegui il debug della funzione Lambda in locale .................................................................... 79
Test del API Gateway localmente ........................................................................................ 82
Impostazioni avanzate ....................................................................................................... 84
Ulteriori informazioni .......................................................................................................... 29
Risoluzione dei problemi .................................................................................................................... 87
AWSPlug-in it CodeCommit - Eclipse non è riuscito a scrivere nello store sicuro. ................................. 87
Cronologia dei documenti ................................................................................................................... 88
.................................................................................................................................................. lxxxix
iv
AWS Toolkit for Eclipse Guida per l'utente
Documentazione e risorse aggiuntive
Che cos'è ?AWSToolkit for Eclipse?
LaAWSToolkit for Eclipse è un plug-in open source per l'ambiente di sviluppo integrato (IDE) Eclipse che
semplifica agli sviluppatori la creazione, il debug e la distribuzione di applicazioni Java che usano Amazon
Web Services. Migliora l'IDE Eclipse con caratteristiche aggiuntive:
• LaAWS SDK for Javaè incluso e gestito da Maven quando si crea una nuovaAWSutilizzando l'Toolkit for
Eclipse.
• AWSExplorer, un'interfaccia per Amazon Web Services che consente di gestireAWSrisorse provenienti
dall'ambiente Eclipse.
• Creazione, sviluppo e debug di un piano di progetto Java di AWS Lambda e un progetto SAM
(Serverless Application Model)
• Clonazione del repository AWS CodeCommit
• Integrazione con AWS CodeStar
• Distribuzione e debug di Elastic Beanstalk
• Un editor di modelli AWS CloudFormation
• Il Support per piùAWSconti
Important
Non sono previsti costi per l'utilizzo di Toolkit for Eclipse, tuttavia, possono essere
applicatiAWSaddebiti per la creazione o l'utilizzoAWS risorse addebitabili, come l'esecuzione di
Amazon EC2
istanze o utilizzo di storage Amazon S3. Puoi utilizzare il pluginAWSCalculator dei prezzi diper
stimare i costi per l'utilizzo di varieAWS
risorse AWS.
Documentazione e risorse aggiuntive
Oltre a questa guida, per gli utenti di Toolkit for Eclipse è disponibile una serie di altre risorse:
• AWSGuida per sviluppatori di SDK K per Java
• AWSRiferimento dell'API SDK for Java
• Blog per gli sviluppatori Java
• Forum per gli sviluppatori Java
• GitHub:
• documentazione codice sorgente
• problemi sulla documentazione
• codice sorgente del toolkit
• problemi del toolkit
• @awsforjava (Twitter)
• Licenza del Toolkit
• Domande frequenti sul Toolkit
• Nozioni di base sugliAWSSDK per Java
• Utilizzo diAWSElastic Beanstalk conAWSToolkit for Eclipse (video)
• AWSToolkit for Eclipse: Gestione di Amazon EC2 (video)
1
AWS Toolkit for Eclipse Guida per l'utente
Impostazione del Toolkit
Nozioni di base
Questa sezione fornisce informazioni per coloro che iniziano a utilizzare Toolkit for Eclipse, incluse le
informazioni su come installare e configurare Toolkit for Eclipse.
Argomenti
• Impostazione del Toolkit (p. 2)
• ConfigurazioneAWSCredenziali (p. 3)
• Associazione delle chiavi private alle coppie di chiavi Amazon EC2 (p. 6)
Impostazione del Toolkit
In questa sezione sono riportate le istruzioni per installare o aggiornare Toolkit for Eclipse.
Prerequisites
Il Toolkit for Eclipse ha i seguenti requisiti preliminari:
• Un account Amazon Web Services— Come ottenere unAWSaccount, vai alAWShome pagee clicca
suRegistrazione ora. La registrazione consente di utilizzare tutti i servizi offerti daAWS.
• Un sistema operativo supportato— Il Toolkit for Eclipse è supportato da Windows, Linux, macOS o Unix.
• Java 1.8
• Eclipse IDE per sviluppatori Java 4.2 o versioni successive— Proviamo a mantenere Toolkit for Eclipse
sempre aggiornato con la versione predefinita disponibile sulPagina download di Eclipse.
Note
Eclipse fornisce una serie di download diversi. Consigliamo di installare ilEclipse IDE
per sviluppatori Java aziendali, che include ilPiattaforma Eclipse Web Toolsrichiesto da
Elastic Beanstalk, ilPiattaforma Eclipse Data Toolsrichiesto per le funzionalità di Amazon
SimpleDB,Eclipse eGit, e ilEclissi m2. Se si installa un'altra versione di Eclipse, assicurarsi di
disporre (o di installare, utilizzando i link forniti) del supporto di queste funzionalità.
Installa il Toolkit for Eclipse
Per installareAWSToolkit for Eclipse
1. All'interno di Eclipse, fai clic su Help (Aiuto) quindi fai clic su Install New Software (Installa nuovo
software).
2. NellaUtilizzo discatola, tipohttps://aws.amazon.com/eclipse; quindi premiEnter.
3. Seleziona i componenti del Toolkit for Eclipse da installare. Fai clic su Select All (Seleziona tutto) per
installare tutti i componenti contemporaneamente.
Note
• AWSToolkit for Eclipse Core(nelAWSStrumenti di gestione principalisezione) ènecessario;
tutti gli altri componenti sono opzionali.
2
AWS Toolkit for Eclipse Guida per l'utente
Aggiornamento del Toolkit for Eclipse
• Il Support per i manager Amazon RDS o Amazon SimpleDB richiede chePiattaforma
Eclipse Data Tools(DTP) è installato. La DTP viene installata per impostazione
predefinita con la versione "Java EE Developers" di Eclipse oppure può essere installata
separatamente.
4. Una volta effettuate le selezioni, fai clic su Next (Avanti) (o Finish (Fine)) per completare l'installazione.
Una volta configurato Toolkit for Eclipse è necessarioconfigura ilAWSCredenziali (p. 3).
Note
A seconda delle opzioni selezionate e di altri fattori come la velocità di rete, la latenza del server e
le capacità del sistema, per il completamento possono essere necessari fino a 30 minuti.
Aggiornamento del Toolkit for Eclipse
Per aggiornare o reinstallare Toolkit for Eclipse, utilizza le stesse istruzioni perinstallazione del
toolkit (p. 2).
Alcune versioni di Eclipse (in particolare Mars e Neon) potrebbero non essere in grado di recuperare gli
artefatti più recenti a causa di un bug nelle vecchie versioni del plugin Oomph. Per risolvere il problema:
1. Assicurati di utilizzarehttps://aws.amazon.com/eclipse/site.xmlcome sito di aggiornamento
Toolkit for Eclipse.
2. Elimina la cartella ~/.eclipse/org.eclipse.oomph.p2/cache/ per rimuovere i contenuti
memorizzati nella cache.
3. Installa la versione più recente di Oomph (Eclipse Installer).
ConfigurazioneAWSCredenziali
Per accedere ad Amazon Web Services con Toolkit for Eclipse, è necessario configurare il Toolkit for
Eclipse conAWScredenziali dell'account.
Ottenimento delle chiavi di accesso AWS
Le chiavi di accesso sono costituite da un ID chiave di accesso e una chiave di accesso segreta che sono
utilizzati per firmare le richieste programmatiche effettuate ad AWS. Se non disponi di chiavi di accesso,
puoi crearle utilizzandoNozioni di base sugliAWS Management Console. Consigliamo di utilizzare le chiavi
di accesso IAM invece delle chiavi di accesso dell'account root di AWS. IAM consente di controllare in
modo sicuro l'accesso ai servizi e alle risorse AWS nel tuo account AWS.
Note
Per creare le chiavi delle credenziali d'accesso, bisogna disporre delle autorizzazioni per effettuare
le operazioni richieste dalle azioni IAM. Per ulteriori informazioni, consulta la sezione Concessione
dell'autorizzazione all'utente IAM per gestire policy della password e credenziali nella Guida per
l'utente IAM.
Per ottenere l'ID della chiave di accesso e la chiave di accesso
segreta
1. Aprire la console IAM.
3
AWS Toolkit for Eclipse Guida per l'utente
Aggiungi il tuoAWSchiavi di accesso al Toolkit for Eclipse
2. Nel menu di navigazione, scegliere Users (Utenti).
3. Selezionare il tuo nome utente IAM; (non la casella di spunta).
4. Aprire la scheda Security credentials (Credenziali di sicurezza) e quindi scegliere Create access key
(Crea chiave di accesso).
5. Per visualizzare la nuova chiave di accesso, seleziona Show (Mostra). Le credenziali sono simili ai
seguenti:
• ID chiave di accesso: AKIAIOSFODNN7EXAMPLE
• Chiave di accesso segreta wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
6. Per fare il download della coppia di chiavi, scegliere Download .csv file. Archivia le chiavi
in un percorso sicuro.
Important
Mantieni la riservatezza delle chiavi per proteggere il tuo account AWS e non inviarle mai via
e-mail. Non condividerle all'esterno della tua organizzazione, anche se ricevi una richiesta che
sembra provenire da AWS o Amazon.com. Nessuno che rappresenta legittimamente Amazon
richiederà mai la tua chiave segreta.
Argomenti correlati
• Cos'è IAM? nella Guida per l'utente IAM.
• AWSSecurity CredentialsnellaAWSRiferimenti generali.
Aggiungi il tuoAWSchiavi di accesso al Toolkit for
Eclipse
Toolkit for Eclipse utilizza lo stesso sistema per individuare e usareAWSchiavi di accesso come quelle
utilizzate dalAWSCLI eAWSSDK Java. Le chiavi di accesso immesse nell'IDE di Eclipse vengono salvate in
uncondivisoAWSfile delle credenziali(chiamatocredentials) nel.awsnella directory principale.
Note
La posizione del file delle credenziali può essere modificata. Per ulteriori informazioni
sull'impostazione della posizione del file, consultaModifica dellaAWSPosizione del file delle
credenziali (p. 6).
Se hai già impostato il tuoAWSutilizzando le credenzialiAWSCLI, quindi Toolkit for Eclipse rileverà
automaticamente e utilizzerà tali credenziali. Per ulteriori informazioni sull'utilizzo diAWSCLI, consultaAWS
CLIRiferimento ai comandi.
Per aggiungere le chiavi di accesso aAWSToolkit for Eclipse
1. Aprire EclipsePreferenzefinestra di dialogo e cliccaAWSKit di strumentinella barra laterale.
2. Digita o incolla il tuoAWSID chiave di accesso nelAccess Key ID (ID chiave di accesso)(Creare
snapshot finale?).
3. Digita o incolla il tuoAWSchiave di accesso segreta nellaSecret Access Key (Chiave di accesso
segreta)(Creare snapshot finale?).
4. Fai clic su Apply (Applica) o su OK per memorizzare le informazioni sulla chiave di accesso.
Ecco un esempio di un set di credenziali predefinite configurato:
4
AWS Toolkit for Eclipse Guida per l'utente
Utilizzo di piùAWSaccount con il Toolkit for Eclipse
Utilizzo di piùAWSaccount con il Toolkit for Eclipse
LaPreferenzeconsente di aggiungere informazioni per più di unaAWSconto. Gli account multipli possono
essere utili, ad esempio, per fornire agli sviluppatori e agli amministratori risorse separate per lo sviluppo e
per il rilascio o la pubblicazione.
Set separati diAWSLe credenziali sono memorizzate comeprofiliall'interno del condivisoAWSfile delle
credenziali descritto inAggiungi il tuoAWSchiavi di accesso alAWSToolkit for Eclipse (p. 4). Tutti i profili
configurati possono essere visualizzati nella casella a discesa nella parte superiore dellaAWSSchermata
Configurazione globale delle preferenze Toolkit, etichettataProfilo predefinito.
Per aggiungere un nuovo set di chiavi di accesso
1. SulAWSPreferenze del Toolkitschermo in EclipsePreferenzefinestra di dialogo, fare clic suCome
aggiungere profilo.
2. Aggiungi le informazioni relative al nuovo account nella sezione Profile Details (Dettagli profilo).
Scegli un nome descrittivo per Profile Name (Nome profilo) e inserisci le informazioni sulle chiavi di
accesso nelle caselle Access Key ID (ID chiave di accesso) e Secret Access Key (Chiave di accesso
segreta).
3. Fai clic su Apply (Applica) o su OK per memorizzare le informazioni sulla chiave di accesso.
È possibile ripetere questa procedura per tutti set diAWSinformazioni sull'account di cui hai bisogno.
Quando hai inserito tutto il tuoAWSPer le informazioni relative all'account, seleziona l'account predefinito
scegliendo uno degli account dall'Profilo predefinitodiscesa.AWS Explorer visualizza le risorse associate
all'account predefinito e, al momento della creazione di una nuova applicazione tramite Toolkit for Eclipse,
l'applicazione utilizza le credenziali per l'account predefinito configurato.
5
AWS Toolkit for Eclipse Guida per l'utente
Modifica dellaAWSPosizione del file delle credenziali
Note
Per un approccio alternativo per separare il tuoAWSconsultaDifferenziazioneAWSRisorse con
denominazione (p. 14).
Modifica dellaAWSPosizione del file delle credenziali
Utilizzando la schermata delle preferenze di Toolkit for Eclipse, è possibile modificare la posizione utilizzata
dal Toolkit per memorizzare e caricare le credenziali.
Per impostare ilAWSPosizione del file delle credenziali
• NellaAWSFinestra di dialogo Preferenze Toolkit, individuaPosizione del file delle credenzialisezione,
quindi inserisci il percorso del file in cui si desideraAWScredenziali memorizzate.
Important
Èfortemente consigliatoche non memorizziAWSInformazioni sulle credenziali all'interno di qualsiasi
directory condivisa in rete o all'interno di progetti su cui operano sistemi di gestione del codice
sorgente. Mantenere sempre un controllo rigoroso delAWSchiavi di accesso!
Associazione delle chiavi private alle coppie di
chiavi Amazon EC2
Il Toolkit for Eclipse può ottenere le coppie di chiavi Amazon EC2AWS. Tuttavia, è necessario associare le
chiavi private per utilizzarle con Toolkit for Eclipse
Per visualizzare le coppie di chiavi Amazon EC2 nellaAWSToolkit for Eclipse e associare le chiavi private
1. Aprire EclipsePreferenzefinestra di dialogo e fai clic sul triangolo accanto aAWSKit di strumentinella
barra laterale per mostrare altre categorie di impostazioni Toolkit for Eclipse.
6AWS Toolkit for Eclipse Guida per l'utente
Associazione delle chiavi private
alle coppie di chiavi Amazon EC2
2. Seleziona Key Pairs (Coppie di chiavi).
Eclipse visualizza un elenco scorrevole delle coppie di chiavi. Se una coppia di chiavi presenta una X
rossa a fianco, è necessario associare una chiave privata alla coppia di chiavi per l'utilizzo.
3. Fai clic con il pulsante destro del mouse sulla coppia di chiavi e dal menu contestuale seleziona Select
Private Key File... (Seleziona file delle chiavi private...)
4. Naviga fino al file delle chiavi private e selezionalo per associarlo alla coppia di chiavi.
7AWS Toolkit for Eclipse Guida per l'utente
In fase di creazioneAWSApplicazione Java
Elemento fondamentali di Toolkit for
Eclipse
Questa sezione fornisce informazioni su come eseguire comuni attività di sviluppo con Toolkit for Eclipse.
Argomenti
• In fase di creazioneAWSApplicazione Java (p. 8)
• Progetti serverless (p. 10)
• DifferenziazioneAWSRisorse con denominazione (p. 14)
In fase di creazioneAWSApplicazione Java
In questa sezione, utilizzeremo il Toolkit for Eclipse per creare ed eseguire un'applicazione Java locale che
accedeAWSrisorse AWS.
Il Toolkit for Eclipse include l'SDK for Java e una serie di programmi di esempio Java. Il Toolkit
for Eclipse consente di creare ed eseguire facilmente uno di questi esempi. Per dimostrare
come Toolkit for Eclipse può aiutarti a creare ed eseguireAWSapplicazioni in Java, useremo
ilAmazonSimpleQueueServicecampione come esempio. LaAWSExplorer fornito con Toolkit for Eclipse può
essere utilizzato per visualizzare la coda Amazon SQS in esecuzione.
Note
L'SDK per i campioni Java è fornito nellasamplesnella cartella di download SDK e può essere
visualizzata anche suGitHub. Per ulteriori informazioni sull'SDK for Java, consulta laAWSGuida
per sviluppatori SDK for Java.
Crea ed esegui l'esempio Amazon Simple Queue
Service
Per creare ed eseguire l'esempio Amazon Simple Queue Service
1. Fai clic sull'icona della barra degli strumentiAWSnella barra degli strumenti di Eclipse, quindi fai clic
suNovitàAWSProgetto Java.
2. Nella finestra di dialogo visualizzata digita un nome per il progetto nella casella Project name (Nome
progetto) e seleziona Amazon Simple Queue Service Sample (Esempio di servizio di coda semplice
Amazon).
8AWS Toolkit for Eclipse Guida per l'utente
Crea ed esegui l'esempio Amazon Simple Queue Service
3. Fare clic su Fine.
4. L'applicazione di esempio viene visualizzata in Project Explorer. Espandi la visualizzazione ad albero per
questo progetto.
5. Sotto il nodo src, fai doppio clic sul file del codice sorgente SimpleQueueService.java per aprirlo nel
riquadro dell'editor. Individua la riga seguente:
System.out.println("Receiving messages from MyQueue.\n");
6. Fai clic con il pulsante destro del mouse sul margine sinistro del riquadro dell'editor e seleziona Toggle
Breakpoint (Attiva punto di interruzione).
9AWS Toolkit for Eclipse Guida per l'utente
Progetti serverless
7. Fai clic con il pulsante destro del mouse sul nodo del progetto in Project Explorer (nel nostro esempio, si
tratta del nodo denominato myJavaSqsApp), quindi fai clic su Debug As > Java Application.
8. Nella finestra di dialogo Select Java Application (Seleziona applicazione Java), seleziona l'applicazione
SQS, quindi fai clic su OK.
9. Quando l'applicazione si ferma al punto di interruzione, Eclipse richiede se passare alla prospettiva
Debug. Fare clic suNo(la prospettiva Debug non includeAWSExplorer).
10.Andare suAWSEsploratoreed espandere ilAmazon SQSNodo.
11.Fai doppio clic su MyQueue e visualizza il contenuto della coda creata dall'applicazione client Java.
12.Premi F8. L'applicazione client Java proseguirà l'esecuzione e terminerà normalmente.
13.Aggiorna la visualizzazione inAWSEsploratore. La coda MyQueue non è più presente: l'applicazione
elimina la coda prima di uscire.
Note
Se si esegue l'applicazione di esempio ripetutamente, è necessario attendere almeno 60
secondi tra esecuzioni successive. Amazon SQS richiede che passino almeno 60 secondi dopo
l'eliminazione di una coda prima di creare una coda con lo stesso nome.
Progetti serverless
Toolkit for Eclipse include una procedura guidata di creazione di progetti che è possibile utilizzare per
configurare e creare rapidamente progetti serverless distribuiti suAWS CloudFormationed esegui le funzioni
Lambda in risposta alle richieste Web RESTful.
Creazione di un progetto serverless
Per creare un progetto serverless
1. Selezionare ilAWSicona sulla barra degli strumenti e scegliereNovitàAWSprogetto serverless...dal
menu che appare.
2. Inserisci un Nome di progetto.
3. Inserisci uno Spazio dei nomi del pacchetto per il progetto. Questo sarà usato come prefisso per gli
spazi dei nomi di origine creati per il progetto.
4. Scegli tra Select a blueprint (Seleziona un piano) o Select a serverless template file (Seleziona un file
di modello serverless):
10AWS Toolkit for Eclipse Guida per l'utente
Creazione di un progetto serverless
Seleziona un piano
Scegli un piano di progetto predefinito (p. 12) da utilizzare per il progetto serverless.
Seleziona un file di modello serverless
Scegli un file Serverless Application Model (SAM) in formato JSON .template sul file system per
personalizzare completamente il progetto serverless.
Note
Per informazioni sulla struttura e sul contenuto di un file .template, consultare la versione
corrente della specifica su GitHub.
5. Premi il pulsante Finish (Fine) per creare il nuovo progetto serverless.
The serverless project wizard
11AWS Toolkit for Eclipse Guida per l'utente
Piani di progetto serverless
Piani di progetto serverless
Sono disponibili i seguenti piani di progetto serverless:
articolo
Questo piano crea un bucket S3 per l'archiviazione del contenuto dell'articolo e una tabella DynamoDB
per i metadati dell'articolo. Contiene funzioni Lambda per il recupero (GetArticle) e conservazione
(PutArticle) articoli, che vengono attivati da eventi di API Gateway.
hello-world
Un piano semplice che crea una funzione Lambda che prende una singola stringa. Il relativo output è
Hello, value , dove value è la stringa passata, oppure World se nessuna stringa è stata passata
alla funzione.
Struttura di progetto serverless
La procedura guidata per progetti serverless creerà un nuovo progetto Eclipse, che è composto dalle
seguenti parti:
• La cartella src contiene due sottocartelle, ciascuna avente come prefisso lo spazio dei nomi del
pacchetto scelto:
mynamespace.function
Contiene i file di classe per le funzioni Lambda che vengono definite dal modello serverless.
mynamespace.model
Contiene genericoServerlessInputeServerlessOutputclassi che definiscono il modello di
input e output per le funzioni Lambda.
Note
Per ulteriori informazioni sui formati di input e output utilizzati nelle classi di modello,
consulta laConfigurazione di un'integrazione proxy per una risorsa proxy(Italiano)
dellaGuida per sviluppatori di API Gateway.
• Laserverless.templateil file definisce ilAWSrisorse e funzioni Lambda (una risorsa di tipo «AWS#
Serverless:Function») utilizzate dal progetto.
Distribuzione di un progetto serverless
Per distribuire un progetto serverless
1. Nella finestra Project Explorer di Eclipse, seleziona il progetto e apri il menu contestuale (facendo clic
con il pulsante destro del mouse o tenendo premuto).
2. Nel menu contestuale, scegli Amazon Web Services ‣ Deploy Serverless Project... (Amazon
Web Services ‣ Distribuisci progetto serverless...). Questo richiederà ilDistribuzione serverless
suAWSCloudFormationfinestra di dialogo.
3. Selezionare ilAWSRegionida usare. Questo determina dove si trova lo stack AWS CloudFormation
distribuito.
4. Scegliere unBucket S3da utilizzare per memorizzare il codice funzione Lambda o selezionare
ilCreateper creare un nuovo bucket S3 per archiviare il codice.
5. Scegli un nome per lo stack AWS CloudFormation.
12AWS Toolkit for Eclipse Guida per l'utente
Vedi anche
6. Premere ilTerminapulsante per caricare le funzioni Lambda su Amazon S3 e distribuire il modello di
progetto suAWS CloudFormation.
The serverless project deployment dialog
Quando il progetto viene distribuito, viene visualizzata una finestra di dettaglio per lo stack AWS
CloudFormation che fornisce informazioni sulla distribuzione e il relativo stato corrente. Inizialmente lo
stato verrà visualizzato come CREATE_IN_PROGRESS. Quando lo stato diventa CREATE_COMPLETE, la
distribuzione è attiva.
Per tornare a questa finestra in qualsiasi momento, apri ilAWSEsploratore, selezionare
ilAWSCloudFormationnodo, quindi selezionare il nome delAWS CloudFormationstack specificato.
Note
Se si verifica un errore durante la distribuzione, può essere eseguito il rollback dello stack.
Consulta .Risoluzione dei probleminellaAWS CloudFormationGuida per l’utente diper informazioni
su come diagnosticare gli errori di distribuzione dello stack.
Vedi anche
• AWSmodello di applicazione serverless (GitHub)
13AWS Toolkit for Eclipse Guida per l'utente
DifferenziazioneAWSRisorse con denominazione
• LaAWSEditor di modelli CloudFormation (p. 37)
• Utilizzo di Lambda conAWSToolkit for Eclipse (p. 20)
DifferenziazioneAWSRisorse con denominazione
Durante lo sviluppo di nuovi prodotti o funzionalità, è utile mantenereAWSrisorse che vengono utilizzate per
lo sviluppo separate dalle risorse che vengono utilizzate per la produzione. Un approccio al mantenimento
di questa separazione è stato discusso nelConfigurazioneAWSCredenziali (p. 3)In altre parole, utilizzare
diversi account per le risorse di sviluppo e di produzione. Questo approccio funziona particolarmente
bene quando si utilizzaAWSExplorer, perchéAWSExplorer visualizza le risorse in base alle credenziali
dell'account. Questa sezione illustrerà un approccio alternativo in cui viene utilizzata una convenzione di
denominazione per distinguere le risorse di sviluppo e di produzione e in cui il supporto per la convenzione
di denominazione è implementato nel codice.
L'idea di base è distinguere il tuoAWSrisorse, ad esempio i bucket Amazon Simple Storage Service
(Amazon S3) o i domini Amazon SimpleDB, aggiungendo una stringa specifica al nome della risorsa. Ad
esempio, invece di denominare il dominio Amazon SimpleDB «clienti», è possibile denominarlo «clienti-
dev» per l'uso nello sviluppo o «cliente-prod» per l'uso nella produzione. Tuttavia, si presenta un problema
se si deve spostare il codice di sviluppo nella produzione. A questo punto, è necessario modificare tutte
queste stringhe, probabilmente attraverso un certo numero di operazioni di ricerca e sostituzione globale
che potrebbero essere noiose o suscettibili di errori. Un metodo più efficiente è quello di aggiungere il
supporto per la convenzione di denominazione nel codice.
14AWS Toolkit for Eclipse Guida per l'utente
DifferenziazioneAWSRisorse con denominazione
La classe StageUtils fornisce il metodo seguente.
public static String getResourceSuffixForCurrentStage()
Il metodo getResourceSuffixForCurrentStage restituisce una stringa che corrisponde alla "fase"
nel ciclo di vita del software in cui è utilizzata la risorsa, ad esempio "dev", "beta" o "prod". Questa stringa
può quindi essere aggiunta agli identificatori delle risorse utilizzate nel codice. È possibile utilizzare
getResourceSuffixForCurrentStage per costruire i nomi delle risorse. Ad esempio, il seguente
metodo, getTopicName, restituisce un nome univoco per un argomento di Amazon SNS. Notare come
incorpora il valore restituito da getResourceSuffixForCurrentStage in questo nome.
private String getTopicName (Entry entry) {
return "entry" + StageUtils.getResourceSuffixForCurrentStage() + "-" + entry.getId();
}
15AWS Toolkit for Eclipse Guida per l'utente
DifferenziazioneAWSRisorse con denominazione
Il valore restituito da getResourceSuffixForCurrentStage viene recuperato dalla proprietà di sistema
Java "application.stage". È possibile specificare questo valore impostando la proprietà di sistema nella
configurazione del container di Elastic Beanstalk.
Note
In Toolkit for Eclipse, l'applicazione Elastic Beanstalk deve essere operativa in modo da consentire
l'accesso alla configurazione del container. La modifica e il salvataggio della configurazione
causano il riavvio automatico dell'applicazione con la nuova configurazione.
Per accedere al pannello delle opzioni Container/JVM per il tuoAWSApplicazione Elastic Beanstalk
1. Nello statoAWSEsploratore, espandi ilAWSElastic BeanstalkNodo AND
2. Sotto il nodo dell'applicazione, fai doppio clic sull'ambiente Elastic Beanstalk.
3. Nella parte inferiore del riquadro Overview (Panoramica), fai clic sulla scheda Configuration
(Configurazione).
4. Nell'area Container, configura le opzioni del container.
5. Nella casella Additional Tomcat JVM command line options (Opzioni aggiuntive della riga di comando
della JVM di Tomcat) specifica il valore per la proprietà di sistema application.stage aggiungendo
l'opzione della riga di comando -D. Ad esempio, è possibile utilizzare la sintassi seguente per specificare
che il valore di stringa deve essere "-beta".
-Dapplication.stage=beta
Si noti che getResourceSuffixForCurrentStage antepone automaticamente un trattino a qualsiasi
valore di stringa specificato.
6. Dopo aver aggiunto il valore della proprietà del sistema, fai clic sul menu File, quindi su Save (Salva).
Eclipse salverà la nuova configurazione. L'applicazione si dovrebbe riavviare automaticamente. È
possibile controllare la scheda Events (Eventi) nella parte inferiore dell'editor Eclipse per individuare
l'evento che indica la corretta distribuzione della nuova configurazione nell'ambiente.
7. Dopo il riavvio dell'applicazione, espandi laAmazon SimpleDBNodo inAWSEsploratore. Viene
visualizzato un nuovo set di domini che utilizzano il valore di stringa specificato.
16AWS Toolkit for Eclipse Guida per l'utente
DifferenziazioneAWSRisorse con denominazione
Note
Per ulteriori informazioni sulla configurazione del container, consultaCreazione e distribuzione di
applicazioni Java inAWSElastic BeanstalknellaAWS Elastic BeanstalkGuida per gli sviluppatori.
17AWS Toolkit for Eclipse Guida per l'utente
Come accedere a .AWSEsploratore
Utilizzo di servizi AWS
AWSExplorer offre una visualizzazione e permette la manipolazione di più Amazon Web Services
contemporaneamente. Questa sezione fornisce informazioni su come accedere e utilizzare laAWSVista
Explorer in Eclipse.
Presume che tu l'abbia già fattoinstallato (p. 2)Toolkit for Eclipse sul sistema.
Argomenti
• Come accedere a .AWSEsploratore (p. 18)
• Utilizzo di Lambda con il Toolkit for Eclipse (p. 20)
• LaAWS CloudFormationeditor di modelli (p. 37)
• Utilizzo di DynamoDB conAWSEsploratore (p. 46)
• Avvio di un'istanza Amazon EC2 (p. 50)
• Gestione dei gruppi di sicurezzaAWSEsploratore (p. 54)
• Visualizzazione e aggiunta delle notifiche Amazon SNS (p. 57)
• Connessione a Amazon Relational Database Service (Amazon RDS) (p. 59)
• Identity and Access Management (p. 61)
• Eseguire il debug di applicazioni serverless tramiteAWSSAM local (p. 76)
Come accedere a .AWSEsploratore
Per visualizzareAWSExplorer, fai clic sulAWSicona sulla barra degli strumenti e
selezionaMostraAWSVisualizzazione Explorer.
18AWS Toolkit for Eclipse Guida per l'utente
Come accedere a .AWSEsploratore
AWS Icon Menu
Note
Se il fileAWSicona non è visibile sulla barra degli strumenti, fare clic sulWindowmenu, quindi fare
clic suOpen Perspective | Altro. Fare clic suAWSGestionedall'elenco delle prospettive di Eclipse.
È possibile espandere ogni nodoAWSExplorer per visualizzare le risorseAWSassociati al tuo account.
Ad esempio, se fai clic sul triangolo bianco a sinistra delAmazon EC2nodo, espanderà e visualizzerà le
risorse Amazon EC2 associate al tuoAWSconto. Toolkit for Eclipse utilizzaAWSaccount che hai configurato
nelConfigurazioneAWSCredenziali (p. 3)per determinare quali risorse visualizzare.
19AWS Toolkit for Eclipse Guida per l'utente
Utilizzo di Lambda con il Toolkit for Eclipse
Se si seleziona uno dei sottonodi di Amazon EC2, Eclipse aprirà una vista con informazioni dettagliate su
quelle risorse. Ad esempio, fare doppio clicIstanzeApre una vista che elenca informazioni su ognuna delle
istanze Amazon EC2, quali il nome DNS pubblico, la zona di disponibilità e il tempo di lancio.
Utilizzo di Lambda con il Toolkit for Eclipse
Toolkit for Eclipse fornisce supporto per la creazione di codice perAWSLambda. Lambda è un servizio
di elaborazione gestito che esegue il codice in risposta a eventi generati dal codice personalizzato o da
vari.AWSservizi come Amazon S3, DynamoDB, Kinesis, Amazon SNS e Amazon Cognito.
Questa sezione riguarda principalmente come utilizzare le caratteristiche del Toolkit for Eclipse per creare,
distribuire ed eseguire le funzioni Lambda.
Argomenti
• Tutorial: Come creare, caricare e richiamare unAWS LambdaFunzione (p. 21)
• AWS LambdaDocumentazione di riferimento per l'interfaccia di (p. 30)
20AWS Toolkit for Eclipse Guida per l'utente
Tutorial: Come creare, caricare e
richiamare unAWS LambdaFunzione
Tutorial: Come creare, caricare e richiamare unAWS
LambdaFunzione
Questo tutorial descrive il processo di un tipicoAWS Lambdae fornisce un'esperienza diretta dell'utilizzo di
Lambda con il Toolkit for Eclipse.
Important
Il tutorial presuppone che tu abbia unAWSaccount, hai giàinstallatoAWSToolkit for Eclipse (p. 2)e
che comprendi i concetti e le caratteristiche di base di Lambda. Se non si ha familiarità con
Lambda, ulteriori informazioni sono reperibili sullaLambdahome page e nelAWSGuida per
sviluppatori Lambda.
Creazione di un progetto AWS Lambda
Per iniziare un progetto Lambda, occorre prima implementare il codice come metodo in una classe del
gestore. Il Toolkit for Eclipse fornisce una procedura guidata per i nuovi progetti per supportare la creazione
di una nuova classe del gestore. Il progetto Lambda è un progetto Maven che utilizza un file POM.xml per
gestire le dipendenze di pacchetti. È possibile utilizzare lo strumento a riga di comando Maven per creare,
testare e distribuire l'applicazione. Per ulteriori informazioni su Maven, consultare la documentazione del
progetto Maven.
Per creare un progetto AWS Lambda
1. Nella barra degli strumenti di Eclipse, apri il menu Amazon Web Services (identificato dallaAWSicona
homepage), quindi scegliNovitàAWSProgetto Lambda Java. In alternativa, sulla barra dei menu di
Eclipse, scegliFile,Novità,AWSProgetto Java Lambda.
2. Aggiungi un nome di progetto, un ID gruppo, un ID artefatto e un nome di classe nelle relative caselle
di input. L'ID gruppo e l'ID artefatto sono gli ID che identificano un artefatto di build Maven. In questo
tutorial vengono utilizzati i seguenti valori di esempio:
• Nome del progetto: HelloLambda
• Group ID: com.example.lambda
• Artifact ID: demo
• Class name (Nome classe): Ciao
Il campo Package Name (Nome package) indica lo spazio dei nomi del pacchetto per la classe
del gestore diAWS Lambda. Il valore predefinito per questo campo è una concatenazione dell'ID
gruppo e dell'ID Artifact, sulla base delle convenzioni del progetto Maven. Il campo viene aggiornato
automaticamente quando sono aggiornati il Group ID (ID gruppo) e l'Artifact ID (ID artefatto).
3. Come Input Type (Tipo di input) scegli Custom (Personalizzato). Per informazioni su ciascuno dei tipi
di input disponibili, consultaNovitàAWSFinestra di dialogo del progetto Lambda (p. 30).
4. Verifica che le voci appaiano come nel seguente screenshot (in caso contrario, modificale), quindi
scegli Finish (Fine).
21AWS Toolkit for Eclipse Guida per l'utente
Tutorial: Come creare, caricare e
richiamare unAWS LambdaFunzione
Man mano che digiti, il codice nella Source preview (Anteprima codice) cambia in modo da riflettere le
modifiche apportate nella finestra di dialogo.
5. Dopo aver scelto Finish (Fine), nel workspace di Eclipse vengono generati la directory del progetto e
i file di origine. Si apre una nuova finestra del browser Web, che visualizzaREADME.html(che è stato
creato nella directory principale del progetto).README.htmlfornisce istruzioni che guidano l'utente
attraverso le fasi successive di implementazione, testing, caricamento e richiamo della nuova funzione
Lambda. Esaminalo per acquisire familiarità con le fasi qui descritte.
22AWS Toolkit for Eclipse Guida per l'utente
Tutorial: Come creare, caricare e
richiamare unAWS LambdaFunzione
Successivamente, implementa la funzione nel progetto Java HelloLambda che è stato appena creato in
Eclipse.
Implementazione del metodo del gestore
Utilizza la finestra di dialogo Create New Project (Crea nuovo progetto) per creare una struttura di progetto.
Ora compila il codice che verrà eseguito quando viene richiamata la funzione Lambda. (in questo caso, da
un evento personalizzato che invia una stringa alla funzione, come specificato durante l'impostazione del
parametro di input del metodo).
Per implementare il metodo del gestore Lambda
1. Nel Project Explorer di Eclipse, apri Hello.java nel progetto HelloLambda. Conterrà un codice simile
a quello visualizzato di seguito.
package com.example.lambda.demo;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
public class Hello implements RequestHandler {
@Override
public String handleRequest(Object input, Context context) {
context.getLogger().log("Input: " + input);
// TODO: implement your handler
return "Hello from Lambda";
}
}
2. Sostituisci il contenuto della funzione handleRequest con il seguente codice.
@Override
public String handleRequest(String input, Context context) {
context.getLogger().log("Input: " + input);
String output = "Hello, " + input + "!";
return output;
}
Consenti a Lambda di assumere un ruolo IAM
Perché Lambda sia in grado di accedere alla funzione Lambda, è necessario creare un ruolo IAM che
garantisca l'accesso alla funzione Lambda.AWSrisorse AWS. È possibile creare il ruolo in due modi,
attraverso laAWS Management Consoleo utilizzando Toolkit for Eclipse. Questa sezione spiega come
creare il ruolo IAM nella console. Consulta .Caricamento del codice (p. 24)per crearne uno utilizzando il
Toolkit for Eclipse.
Per creare un ruolo IAM per Lambda
1. Eseguire l'accesso allaAWSConsole di gestione.
2. Dal menu Services (Servizi), apri la console IAM.
3. Nel riquadro di navigazione, seleziona Roles (Ruoli) e poi Create role (Crea ruolo).
4. PerSelezionare il tipo di entità attendibile, scegliAWSservizioe quindi scegliereLambdaper il servizio
che utilizzerà questo ruolo. Quindi scegli Next (Successivo): Autorizzazioni.
23AWS Toolkit for Eclipse Guida per l'utente
Tutorial: Come creare, caricare e
richiamare unAWS LambdaFunzione
5. Alla voce Attach permissions policy (Collega policy di autorizzazione), scegli
AWSLambdaBasicExecutionRole. In questo modo Lambda può scrivere sulle risorse CloudWatch
Logs. Quindi scegli Next (Successivo): Verifica.
6. Aggiungi un nome, come hello-lambda-role, e una descrizione per il ruolo. Quindi
scegliCreazione di ruoloper completare la creazione del ruolo IAM.
Creare un bucket Amazon S3 per il codice Lambda
AWS Lambdarichiede un bucket Amazon S3 per archiviare il progetto Java quando viene caricato. È
possibile utilizzare un secchio già esistente nelAWSRegione in cui eseguirai il codice oppure crearne uno
nuovo specificatamente perché venga utilizzato da Lambda (opzione consigliata).
È possibile creare un bucket Amazon S3 in due modi, attraverso laAWS Management Consoleo
utilizzando Toolkit for Eclipse. Questa sezione spiega come creare un bucket Amazon S3 nella console.
Consulta .Caricamento del codice (p. 24)per crearne uno utilizzando il Toolkit for Eclipse.
Per creare un bucket Amazon S3 per l'uso con Lambda
1. Eseguire l'accesso allaAWSConsole di gestione.
2. Dal menu Services (Servizi), apri la console S3.
3. Scegliere Create bucket (Crea bucket).
4. Inserisci un nome di bucket e quindi scegli una regione per il bucket. Questa regione deve essere
la stessa in cui si desidera eseguire la funzione Lambda. Per un elenco delle regioni supportate da
Lambda consultaRegioni ed endpointnellaAWSRiferimenti generali.
5. Scegli Create (Crea) per completare la creazione del bucket.
Caricamento del codice
Successivamente, devi caricare il codice in AWS Lambda per poterlo richiamare attraverso la AWS
Management Console.
Per caricare la funzione in Lambda
1. Fai clic con il pulsante destro del mouse nella finestra del codice EclipAWSLambdae quindi
scegliereFunzione di caricamento suAWSLambda.
2. SulSelezione della funzione Lambda target, scegli ilAWSRegione da usare. Questa deve essere la
stessa regione scelta per il bucket Amazon S3 (p. 24).
24AWS Toolkit for Eclipse Guida per l'utente
Tutorial: Come creare, caricare e
richiamare unAWS LambdaFunzione
3. Scegli Create a new Lambda function (Crea una nuova funzione Lambda), quindi digita un nome per la
funzione (ad esempio, HelloFunction).
4. Seleziona Successivo.
5. SulConfigurazione della funzione, immetti una descrizione per la funzione Lambda target e quindi
scegli il ruolo IAM e il bucket Amazon S3 che la funzione utilizzerà.
25AWS Toolkit for Eclipse Guida per l'utente
Tutorial: Come creare, caricare e
richiamare unAWS LambdaFunzione
Per ulteriori informazioni sulle opzioni disponibili, consultaCarica funzione suAWSFinestra di dialogo
Lambda (p. 32).
6. SulConfigurazione della funzionepagina, scegliCreatenelRuolo funzionese intendi creare un nuovo
ruolo IAM per la funzione Lambda. Inserisci un nome di ruolo nella finestra di dialogo Create Role
(Crea ruolo).
26AWS Toolkit for Eclipse Guida per l'utente
Tutorial: Come creare, caricare e
richiamare unAWS LambdaFunzione
7. SulConfigurazione della funzionepagina, scegliPubblica nuova versionese il caricamento deve creare
una nuova versione della funzione Lambda. Per ulteriori informazioni sulla funzione Versioni multiple e
sugli alias di Lambda, consultaAWSFunzione Lambda Versioni multiple e alias della funzionenellaAWS
LambdaGuida per gli sviluppatori.
8. Se scegli di pubblicare una nuova versione, viene abilitata l'opzione Provide an alias to this new
version (Indica un alias per questa nuova funzione). Scegli questa opzione se desideri associare un
alias a questa versione della funzione Lambda.
9. SulConfigurazione della funzionepagina, scegliCreatenellaBucket S3 per codice funzionese intendi
creare un nuovo bucket Amazon S3 per la funzione Lambda. Inserisci un nome di bucket nella finestra
di dialogo Create Bucket (Crea Bucket).
10. Nella sezione S3 Bucket for Function Code (Bucket S3 per il codice della funzione), puoi anche
scegliere di crittografare il codice caricato. Per questo esempio, lascia selezionata la voce None
(Nessuna). Per ulteriori informazioni sulla crittografia Amazon S3, consultaProtezione dei dati con la
crittografia lato servernellaManuale dell'utente di Amazon Simple Storage.
11. Lascia invariate le opzioni Advanced Settings (Impostazioni avanzate). Toolkit for Eclipse seleziona i
valori predefiniti. ScegliereTerminaper caricare la funzione LambdaAWS.
27AWS Toolkit for Eclipse Guida per l'utente
Tutorial: Come creare, caricare e
richiamare unAWS LambdaFunzione
Se il caricamento va a buon fine, potrai vedere il nome della funzione Lambda scelto accanto alla classe
del gestore Java nellaProject Explorervisualizzazione.
Se questo non accade, apri EclipseLog di errorivisualizzazione. Lambda scrive le informazioni sugli errori di
caricamento o esecuzione della funzione in questo log di errori in modo da poterne eseguire il debug.
Richiama la funzione Lambda
È ora possibile richiamare la funzione su AWS Lambda.
Per richiamare la funzione Lambda
1. Fai clic con il pulsante destro del mouse nella finestra Codice EclipseAWSLambdae quindi
scegliereEsecuzione della funzione suAWSLambda.
2. Scegli la classe del gestore da richiamare.
3. Nella casella di input, digita una stringa JSON valida, ad esempio»AWSLambda».
28AWS Toolkit for Eclipse Guida per l'utente
Tutorial: Come creare, caricare e
richiamare unAWS LambdaFunzione
Note
È possibile aggiungere al progetto nuovi file di input JSON, che verranno visualizzati in questa
finestra di dialogo se il nome del file termina con .json. È possibile utilizzare questa funzione
per fornire file di input standard alle funzioni Lambda.
4. La casella Show Live Log (Mostra log in diretta) è selezionata per impostazione predefinita. In questo
modo vengono visualizzati i log dall'output della funzione Lambda in EclipseConsole.
5. ScegliereRichiamoper inviare i dati di input alla funzione Lambda. Se hai configurato tutto
correttamente, vedrai il valore restituito dalla funzione nella vista Console di Eclipse (che appare
automaticamente se non è già visualizzata).
Congratulazioni, hai appena eseguito la tua prima funzione Lambda direttamente dall'IDE di Eclipse!
Fasi successive
Ora che hai caricato e distribuito la funzione, prova a modificare il codice e rieseguire la funzione. Lambda
ricarica e richiama automaticamente la funzione e visualizza l'output su EclipseConsole.
Ulteriori informazioni
Per ulteriori informazioni su ciascuna delle pagine illustrate in questo tutorial e per una descrizione
completa di ciascuna opzione, consultare la sezioneAWSRiferimento per l'interfaccia Lambda (p. 30).
29AWS Toolkit for Eclipse Guida per l'utente
AWS LambdaDocumentazione
di riferimento per l'interfaccia di
Per ulteriori informazioni su Lambda e sulla scrittura di codice Java per Lambda, consultareCreazione di
funzioni Lambda in JavanellaAWS LambdaGuida per gli sviluppatori.
AWS LambdaDocumentazione di riferimento per
l'interfaccia di
Questa sezione fornisce informazioni dettagliate su tutti gli elementi dell'interfaccia utente aggiunti a Eclipse
dal Toolkit for Eclipse perAWS Lambda.
Argomenti
• NovitàAWS LambdaFinestra di dialogo Progetto (p. 30)
• Carica funzione suAWS LambdaFinestra di dialogo (p. 32)
• EseguiAWS LambdaFinestra di dialogo (p. 36)
NovitàAWS LambdaFinestra di dialogo Progetto
LaNuovo progetto Java Lambdaconsente di creare e configurare un nuovo progetto Java che è possibile
utilizzare per creare una funzione Lambda.
Avvio della finestra di dialogo
La finestra di dialogo New Lambda Java Project (Nuovo progetto Java Lambda) può essere avviata nei
seguenti modi:
• aprendoAWSmenu nella barra degli strumenti Eclipse e selezioneNovitàAWSProgetto Lambda Java....
• selezionandoFile ‣ Nuovo ‣ Altro...nel menu Eclipse, quindi scegliendoAWS‣AWSProgetto Java
Lambdanella finestra di dialogo risultante.
30AWS Toolkit for Eclipse Guida per l'utente
AWS LambdaDocumentazione
di riferimento per l'interfaccia di
Interfaccia utente della finestra di dialogo Create Project (Crea progetto)
Nome progetto
Campo obbligatorio. È obbligatorio fornire un nome per il progetto.
Package name (Nome pacchetto)
Nome facoltativo per il pacchetto Java. Deve essere un nome di pacchetto Java valido, ad esempio
"com.mycompany.myproject". Quando si immette il nome del pacchetto nel campo di immissione testo,
questo verrà aggiunto al contenuto della finestra Source Preview (Anteprima origine).
Default: Nessuna, questo parametro è facoltativo.
Class name (Nome classe)
Campo obbligatorio. Il nome che identifica la classe Java che contiene il codice Lambda. Deve essere
un nome valido di una classe Java. Il valore predefinito è generico; è possibile specificare qui un nome
o modificare il Package name (Nome pacchetto) per evitare conflitti con classi con denominazioni
simili.
Default: LambdaFunctionHandler
31Puoi anche leggere
