AWS Toolkit for Eclipse - Guía del usuario - AWS Toolkit for Eclipse: Guía del usuario - AWS Documentation
←
→
Page content transcription
If your browser does not render page correctly, please read the page content below
AWS Toolkit for Eclipse
Guía del usuario
AWS Toolkit for Eclipse: Guía del usuario
Copyright © 2020 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.
AWS Toolkit for Eclipse Guía del usuario 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.
AWS Toolkit for Eclipse Guía del usuario
Table of Contents
What is the AWS Toolkit for Eclipse? ................................................................................................... 1
Additional documentation and resources ........................................................................................ 1
Getting Started ................................................................................................................................... 3
Set up the Toolkit ...................................................................................................................... 3
Prerequisites ...................................................................................................................... 3
Install the AWS Toolkit for Eclipse ........................................................................................ 3
Upgrade the AWS Toolkit for Eclipse ..................................................................................... 4
Set up AWS Credentials ............................................................................................................. 4
Get your AWS access keys ................................................................................................. 4
Add your AWS access keys to the AWS Toolkit for Eclipse ....................................................... 5
Using multiple AWS accounts with the AWS Toolkit for Eclipse .................................................. 6
Changing the AWS credentials file location ............................................................................. 7
Associate Private Keys with Your Amazon EC2 Key Pairs ............................................................... 7
AWS Toolkit for Eclipse Basics ............................................................................................................ 9
Building an AWS Java Application ............................................................................................... 9
Build and Run the Amazon Simple Queue Service Sample ....................................................... 9
Serverless Projects ................................................................................................................... 11
Creating a Serverless Project ............................................................................................. 11
Serverless Project Blueprints .............................................................................................. 13
Serverless Project Structure ............................................................................................... 13
Deploying a Serverless Project ........................................................................................... 13
See Also ......................................................................................................................... 14
Differentiating AWS Resources with Naming ................................................................................ 15
Working with AWS Services .............................................................................................................. 19
How to Access AWS Explorer ................................................................................................... 19
Using Lambda with the AWS Toolkit for Eclipse ........................................................................... 21
Tutorial: How to Create, Upload, and Invoke an AWS Lambda Function .................................... 22
AWS Lambda Interface Reference ..................................................................................... 31
The AWS CloudFormation Template Editor .................................................................................. 38
Adding and Accessing AWS CloudFormation Templates in Eclipse .......................................... 39
Deploying a AWS CloudFormation Template in Eclipse .......................................................... 41
Updating a AWS CloudFormation Template in Eclipse ........................................................... 44
Validating a AWS CloudFormation Template in Eclipse .......................................................... 46
Using DynamoDB with AWS Explorer ......................................................................................... 47
Creating an DynamoDB Table ............................................................................................ 47
Viewing an DynamoDB Table as a Grid ............................................................................... 48
Editing Attributes and Values .............................................................................................. 49
Scanning an DynamoDB Table ........................................................................................... 50
Launch an Amazon EC2 Instance from an Amazon Machine Image ................................................. 51
Managing Security Groups from AWS Explorer ............................................................................ 55
Creating a New Security Group .......................................................................................... 55
Adding Permissions to Security Groups ................................................................................ 56
Viewing and Adding Amazon SNS Notifications ............................................................................ 58
View an Amazon SNS Notification ....................................................................................... 58
Add an Amazon SNS Notification ........................................................................................ 59
Connecting to Amazon Relational Database Service (Amazon RDS) ................................................ 60
Identity and Access Management ............................................................................................... 62
About AWS Identity and Access Management ....................................................................... 62
Create an IAM User .......................................................................................................... 63
Create an IAM Group ........................................................................................................ 64
Add an IAM User to an IAM Group ..................................................................................... 65
Manage Credentials for an IAM User ................................................................................... 66
Create an IAM Role .......................................................................................................... 70
Attach an IAM Policy to a User, Group, or Role ..................................................................... 73
iii
AWS Toolkit for Eclipse Guía del usuario
Set Password Policy ......................................................................................................... 76
Debug Serverless Applications Using AWS SAM Local .................................................................. 77
Prerequisites ...................................................................................................................... 3
Import the SAM Application from AWS CodeStar ................................................................... 78
Debug Lambda Function Locally ......................................................................................... 79
Test API Gateway Locally .................................................................................................. 83
Advanced Settings ............................................................................................................ 85
More Info ......................................................................................................................... 31
Trouble Shooting .............................................................................................................................. 88
AWS CodeCommit plugin - Eclipse was unable to write to the secure store. ....................................... 88
Document History ............................................................................................................................. 89
...................................................................................................................................................... xc
iv
AWS Toolkit for Eclipse Guía del usuario
Additional documentation and resources
What is the AWS Toolkit for Eclipse?
AWS Toolkit for Eclipse es un complemento de código abierto para el entorno de desarrollo integrado
(IDE) de Eclipse que hace más sencillo para los desarrolladores desarrollar, depurar e implementar las
aplicaciones de Java que usan Amazon Web Services. Amplía el IDE de Eclipse con características
adicionales:
• The AWS SDK for Java is included and managed by Maven when you create a new AWS project using
the AWS Toolkit for Eclipse
• AWS Explorer, an interface to Amazon Web Services that allows you to manage your AWS resources
from within the Eclipse environment.
• AWS Lambda Java project and Serverless Application Model (SAM) project blueprint creation,
deployment and debugging
• AWS CodeCommit repository cloning
• Integration with AWS CodeStar
• AWS Elastic Beanstalk deployment and debugging
• An AWS CloudFormation template editor
• Support for multiple AWS accounts
Important
No se aplica ningún cargo por utilizar AWS Toolkit for Eclipse, aunque sí podrían aplicarse cargos
de AWS por crear o usar recursos facturables de AWS, como la ejecución de instancias Amazon
EC2
o el uso de almacenamiento de Amazon S3. Puede utilizar la Calculadora de precios de AWS
para calcular los cargos por el uso de varios recursos
recursos
Additional documentation and resources
Además de esta guía, existen otros recursos disponibles para los usuarios de AWS Toolkit for Eclipse:
• AWS SDK for Java Developer Guide
• AWS SDK for Java API Reference
• Java developer blog
• Java developer forums
• GitHub:
• documentation source
• documentation issues
• toolkit source
• toolkit issues
• @awsforjava (Twitter)
• Toolkit license
• Toolkit FAQ
• Getting Started with the AWS SDK for Java
• Using AWS Elastic Beanstalk with the AWS Toolkit for Eclipse (video)
1
AWS Toolkit for Eclipse Guía del usuario
Additional documentation and resources
• AWS Toolkit for Eclipse: Amazon EC2 Management (video)
2
AWS Toolkit for Eclipse Guía del usuario
Set up the Toolkit
Getting Started
Esta sección proporciona información para aquellos que se inician con AWS Toolkit for Eclipse, incluida
información sobre cómo instalar y configurar AWS Toolkit for Eclipse.
Temas
• Set up the Toolkit (p. 3)
• Set up AWS Credentials (p. 4)
• Associate Private Keys with Your Amazon EC2 Key Pairs (p. 7)
Set up the Toolkit
En esta sección se describe cómo instalar o actualizar AWS Toolkit for Eclipse.
Prerequisites
AWS Toolkit for Eclipse tiene los siguientes requisitos previos:
• An Amazon Web Services account– To obtain an AWS account, go to the AWS home page and click
Sign Up Now. Signing up will enable you to use all of the services offered by AWS.
• A supported operating system– The AWS Toolkit for Eclipse is supported on Windows, Linux, macOS, or
Unix.
• Java 1.8
• Eclipse IDE for Java Developers 4.2 or later– We attempt to keep the AWS Toolkit for Eclipse current
with the default version available on the Eclipse download page.
Note
Eclipse provides a number of different downloads. We recommend installing the Eclipse IDE for
Enterprise Java Developers, which includes the Eclipse Web Tools Platform required by Elastic
Beanstalk, the Eclipse Data Tools Platform required for Amazon SimpleDB features, the Eclipse
EGit, and the M2Eclipse. If you install another version of Eclipse, make sure that you have (or
that you install, using the provided links) support for these features.
• (Optional) Google Android Development Tools (ADT)– if you want AWS Toolkit for Eclipse support for the
AWS Mobile SDK for Android, you must install the ADT first.
Install the AWS Toolkit for Eclipse
Para instalar AWS Toolkit for Eclipse
1. En Eclipse, haga clic en Help y, a continuación, haga clic en Install New Software.
2. En el cuadro Work with, escriba https://aws.amazon.com/eclipse y, a continuación, pulse Enter.
3. Elija los componentes de AWS Toolkit for Eclipse que desea instalar. Haga clic en Select All para
instalar todos los componentes a la vez.
3
AWS Toolkit for Eclipse Guía del usuario
Upgrade the AWS Toolkit for Eclipse
Note
• AWS Toolkit for Eclipse Core (in the AWS Core Management Tools section) is required; all
other components are optional.
• Support for the AWS Mobile SDK for Android requires that you have the Google Android
Developer Tools (ADT) for Eclipse installed first. If you have not yet installed the ADT, make
sure that AWS SDK for Android is unchecked, or installation will fail.
• Support for the Amazon RDS or Amazon SimpleDB managers requires that the Eclipse
Data Tools Platform (DTP) is installed. The DTP is installed by default with the “Java EE
Developers” version of Eclipse, or can be installed separately.
4. Una vez que haya realizado las selecciones, haga clic en Next (o en Finish) para completar la
instalación.
Una vez que haya configurado AWS Toolkit for Eclipse, debe configurar sus credenciales de
AWS (p. 4).
Note
En función de las opciones seleccionadas y de factores como la velocidad de la red, la latencia
del servidor y las capacidades del sistema, la instalación puede tardar hasta 30 minutos en
completarse.
Upgrade the AWS Toolkit for Eclipse
Para actualizar o reinstalar AWS Toolkit for Eclipse, utilice las mismas instrucciones que para instalar el
toolkit (p. 3).
Algunas versiones de Eclipse (notablemente Mars y Neon), puede no recuperar los artefactos más
recientes debido a un error en versiones antiguas de la Complemento Oomph. Para solucionar este
problema:
1. No olvide utilizar https://aws.amazon.com/eclipse/site.xml como sitio de actualización de
AWS Toolkit for Eclipse.
2. Elimine el directorio ~/.eclipse/org.eclipse.oomph.p2/cache/ para eliminar el contenido
almacenado en caché.
3. Instale la versión más reciente de Oomph (Eclipse Installer).
Set up AWS Credentials
Para obtener acceso a Amazon Web Services con AWS Toolkit for Eclipse, debe configurar AWS Toolkit
for Eclipse con las credenciales de la cuenta de AWS.
Get your AWS access keys
Las claves de acceso constan de un access key ID y secret access key, que se utilizan para firmar
solicitudes programáticas que realice a AWS. Si no tiene claves de acceso, puede crearlas utilizando la
consola de administración de AWS. Es recomendable que utilice las claves de acceso de IAM en lugar de
las claves de acceso de la cuenta raíz de AWS. IAM le permite controlar de forma segura el acceso a los
servicios de AWS y a los recursos de su cuenta de AWS.
Note
Para crear claves de acceso, debe tener permisos para realizar las acciones de IAM requeridas.
Para obtener más información, consulte este artículo acerca de cómo conceder permisos de
4
AWS Toolkit for Eclipse Guía del usuario
Add your AWS access keys to the AWS Toolkit for Eclipse
usuario de IAM para administrar la política de contraseñas y las credenciales en la IAM User
Guide.
To get your access key ID and secret access key
1. Abra la consola de IAM.
2. En el menú de navegación, elija Users (Usuarios).
3. Seleccione su nombre de usuario de IAM (no la casilla de verificación).
4. Abra la pestaña Security credentials (Credenciales de seguridad) y, a continuación, seleccione Create
access key (Crear clave de acceso).
5. Para ver la nueva clave de acceso, elija Show (Mostrar). Sus credenciales serán similares a las
siguientes:
• Access key ID: AKIAIOSFODNN7EXAMPLE
• Secret access key: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
6. Para descargar el par de claves, elija Download .csv file (Descargar archivo .csv). Almacene las claves
en un lugar seguro.
Important
Mantenga las claves en secreto para proteger su cuenta de AWS y no las envíe nunca por correo
electrónico. No los comparta fuera de su organización, aunque aparezca una consulta de AWS o
Amazon.com. No one who legitimately represents Amazon will ever ask you for your secret key.
Related topics
• What Is IAM? in IAM User Guide.
• AWS Security Credentials in Amazon Web Services General Reference.
Add your AWS access keys to the AWS Toolkit for
Eclipse
Para localizar y utilizar las claves de acceso de AWS, AWS Toolkit for Eclipse utiliza el mismo sistema
que la interfaz de línea de comandos (CLI) de AWS y AWS Java SDK. Las claves de acceso introducidas
en el IDE Eclipse se guardan en un shared AWS credentials file (llamada credentials) en el .aws
subdirectorio dentro de su directorio de inicio.
Note
La ubicación del archivo de credenciales se puede modificar. Para obtener más información
acerca de la configuración de la ubicación de este archivo, consulte Changing the AWS
credentials file location (p. 7).
Si ya ha establecido las credenciales de AWS a través de la interfaz de línea de comandos (CLI) de
AWS, AWS Toolkit for Eclipse detectará y usará automáticamente esas credenciales. Para obtener más
información acerca del uso de la CLI de AWS, consulte la Guía del usuario de AWS CLI.
Para añadir sus claves de acceso a AWS Toolkit for Eclipse
1. Abra el cuadro de diálogo Preferences (Preferencias) de Eclipse y, en la barra lateral, haga clic en
AWS Toolkit.
5
AWS Toolkit for Eclipse Guía del usuario
Using multiple AWS accounts
with the AWS Toolkit for Eclipse
2. Escriba o pegue el ID de clave de acceso de AWS en el cuadro Access Key ID.
3. Escriba o pegue la clave de acceso secreta de AWS en el cuadro Secret Access Key.
4. Haga clic en Apply o en OK para almacenar la información de su clave de acceso.
A continuación, se muestra un ejemplo de un conjunto de credenciales predeterminadas configurado:
Using multiple AWS accounts with the AWS Toolkit for
Eclipse
El cuadro de diálogo Preferences le permite añadir información para más de una cuenta de AWS. Varias
cuentas pueden ser útiles, por ejemplo, para proporcionar a los desarrolladores y los administradores
recursos independientes para el desarrollo y para el lanzamiento y la publicación.
Los conjuntos independientes de credenciales de AWS se almacenan como profiles dentro del archivo de
credenciales de AWS compartido descrito en Añada las claves de acceso de AWS al kit de herramientas
AWS para Eclipse (p. 5). Todos los perfiles configurados se puede ver en el menú desplegable de
la parte superior de la pantalla Global Configuration de AWS Toolkit Preferences, con la etiqueta Default
Profile.
Para añadir un nuevo conjunto de claves de acceso
1. En la pantalla AWS Toolkit Preferences (Preferencias de AWS Toolkit), en el cuadro de diálogo
Preferences (Preferencias) de Eclipse, haga clic en Add profile (Agregar perfil).
2. Añada la información de la nueva cuenta en la sección Profile Details.
Elija un nombre descriptivo para Profile Name y escriba la información de la clave de acceso en los
cuadros Access Key ID y Secret Access Key.
3. Haga clic en Apply o en OK para almacenar la información de su clave de acceso.
Puede repetir este procedimiento para tantos conjuntos de información de la cuenta de AWS como sea
necesario.
Cuando haya especificado toda la información de su cuenta de AWS, seleccione la cuenta predeterminada
eligiendo una de las cuentas del menú desplegable Default Profile. AWS Explorer muestra los recursos
6AWS Toolkit for Eclipse Guía del usuario
Changing the AWS credentials file location
asociados a la cuenta predeterminada y, cuando se crea una nueva aplicación mediante AWS Toolkit for
Eclipse, la aplicación utiliza las credenciales de la cuenta predeterminada configurada.
Note
Si desea conocer un procedimiento alternativo para separar los recursos de AWS, consulte
Diferenciación de los recursos de AWS mediante la nomenclatura (p. 15).
Changing the AWS credentials file location
En la pantalla Preferences de AWS Toolkit for Eclipse, puede cambiar la ubicación utilizada por el conjunto
de herramientas para almacenar y cargar las credenciales.
To set the AWS credentials file location
• In the AWS Toolkit Preferences dialog, locate the Credentials file location section, and enter the
pathname of the file where you would like your AWS credentials stored.
Important
Es strongly recommended que no almacena la información de credencial de AWS en ningún
directorio compartido de red o en ningún proyecto gestionado por control de fuente. Mantenga
siempre un control estricto de sus claves de acceso de AWS.
Associate Private Keys with Your Amazon EC2 Key
Pairs
AWS Toolkit for Eclipse puede obtener sus pares de claves de Amazon EC2 de AWS. Sin embargo, tendrá
que asociar las claves privadas para utilizarlas con AWS Toolkit for Eclipse.
To view your Amazon EC2 key pairs in the AWS Toolkit for Eclipse and associate private keys with them
1. Abra el cuadro de diálogo Preferences (Preferencias) de Eclipse y haga clic en el triángulo situado junto
a AWS Toolkit en la barra lateral para ver otras categorías de configuración de AWS Toolkit for Eclipse.
7AWS Toolkit for Eclipse Guía del usuario
Associate Private Keys with Your Amazon EC2 Key Pairs
2. Seleccione Key Pairs.
Eclipse muestra una lista desplazable de los pares de claves. Si un par de claves tiene una X roja junto
a él, tendrá que asociar una clave privada con el par de claves para utilizarlo.
3. Haga clic con el botón derecho en el par de claves y, en el menú contextual, seleccione Select Private
Key File... (Seleccionar archivo de clave privada...)
4. Vaya hasta el archivo de la clave privada y selecciónelo para asociarlo con el par de claves.
8AWS Toolkit for Eclipse Guía del usuario
Building an AWS Java Application
AWS Toolkit for Eclipse Basics
En esta sección se proporciona información acerca del modo de realizar las tareas de desarrollo comunes
con AWS Toolkit for Eclipse.
Temas
• Building an AWS Java Application (p. 9)
• Serverless Projects (p. 11)
• Differentiating AWS Resources with Naming (p. 15)
Building an AWS Java Application
En esta sección, vamos a utilizar AWS Toolkit for Eclipse para crear y ejecutar una aplicación local de Java
que accede a los recursos de AWS.
AWS Toolkit for Eclipse incluye AWS SDK for Java y una serie de programas de ejemplo de Java. AWS
Toolkit for Eclipse le facilita la tarea de crear y ejecutar cualquiera de estos ejemplos. Demostrar cómo
el AWS Toolkit for Eclipse puede ayudarle a crear y ejecutar aplicaciones AWS en Java, utilizaremos el
AmazonSimpleQueueService ejemplo como ejemplo. AWS Explorer, que se proporciona con AWS Toolkit
for Eclipse se puede utilizar para ver la cola de Amazon SQS en ejecución.
Note
Los ejemplos de AWS SDK for Java se proporcionan en el directorio samples en la descarga del
SDK y también pueden visualizarse en GitHub. Para obtener más información sobre el AWS SDK
for Java, vea la Guía para desarrolladores de AWS SDK para Java.
Build and Run the Amazon Simple Queue Service
Sample
To build and run the Amazon Simple Queue Service sample
1. Haga clic en el icono de AWS en la barra de herramientas de Eclipse y, a continuación, haga clic en
New AWS Java Project.
2. En el cuadro de diálogo que aparece, escriba un nombre para el proyecto en el cuadro Project name y
seleccione Amazon Simple Queue Service Sample.
9AWS Toolkit for Eclipse Guía del usuario
Build and Run the Amazon Simple Queue Service Sample
3. Haga clic en Finish (Finalizar).
4. La aplicación de ejemplo aparece en Project Explorer. Amplíe la vista de árbol para este proyecto.
5. Bajo el nodo src, haga doble clic en el archivo de origen SimpleQueueService.java para abrirlo en
el panel de editor. Localice la siguiente línea:
System.out.println("Receiving messages from MyQueue.\n");
6. Haga clic con el botón derecho en el margen izquierdo del panel de editor y seleccione Toggle
Breakpoint.
10AWS Toolkit for Eclipse Guía del usuario
Serverless Projects
7. Haga clic con el botón derecho en el nodo del proyecto en Project Explorer. En nuestro ejemplo, este
sería el nodo denominado myJavaSqsApp y, a continuación, haga clic en Debug As > Java Application.
8. En el cuadro de diálogo Select Java Application, seleccione la aplicación SQS y, a continuación, haga
clic en OK.
9. Cuando la aplicación se detiene en el punto de ruptura, Eclipse le preguntará si debería cambiar a la
perspectiva de depuración. Haga clic en No (la perspectiva de depuración no incluye AWS Explorer).
10.Vaya a AWS Explorer y expanda el nodo de Amazon SQS.
11.Haga doble clic en MyQueue y vea el contenido de la cola que creó la aplicación cliente Java.
12.Pulse F8. Cliente Java se seguirá ejecutando y finalizará normalment.
13.Actualice la vista en AWS Explorer. Verá que la cola MyQueue ya no está presente, la aplicación elimina
la cola antes de que la aplicación salga.
Note
Si ejecuta esta aplicación de ejemplo repetidamente, deberá esperar al menos 60 segundos entre
las posteriores ejecuciones. Amazon SQS exige que transcurran al menos 60 segundos después
de eliminar una cola antes de crear una cola con el mismo nombre.
Serverless Projects
AWS Toolkit for Eclipse dispone de un asistente de creación de proyectos que se puede utilizar para
configurar y crear rápidamente proyectos sin servidor que se implementen en AWS CloudFormation y
ejecuten funciones Lambda en respuesta a solicitudes web RESTful.
Creating a Serverless Project
Para crear un proyecto sin servidor
1. Seleccione el icono de AWS en la barra de herramientas y elija New AWS serverless project... (Nuevo
proyecto sin servidor de AWS...) en el menú que aparece.
2. Escriba un nombre en Project name.
3. Escriba un valor en Package namespace para el proyecto. Esto se utilizará como prefijo de los
espacios de nombres de origen creados para el proyecto.
4. Elija Select a blueprint o Select a serverless template file:
Select a Blueprint
Elija un plan de proyecto predefinido (p. 13) para utilizarlo en el proyecto sin servidor.
11AWS Toolkit for Eclipse Guía del usuario
Creating a Serverless Project
Select a Serverless Template File
Elija un archivo .template de modelo de aplicaciones sin servidor (SAM) con formato JSON en
su sistema de archivos para personalizar por completo el proyecto sin servidor.
Note
Para obtener información acerca de la estructura y el contenido de un archivo .template,
vea la versión actual de la especificación en GitHub.
5. Pulse el botón Finish para crear el nuevo proyecto sin servidor.
The serverless project wizard
12AWS Toolkit for Eclipse Guía del usuario
Serverless Project Blueprints
Serverless Project Blueprints
Los siguientes planes de proyectos sin servidor están disponibles:
article
Este plan crea un bucket de S3 para almacenar contenido de artículos y una tabla de DynamoDB
para los metadatos de los artículos. Contiene funciones de Lambda para recuperar (GetArticle) y
almacenar (PutArticle) artículos, que se activan mediante eventos de API Gateway.
hello/world
Un plan sencillo que crea una función de Lambda que toma una única cadena. Su producción es
Hello, value , donde value es la cadena que se aprobó, o World si no se pasa ninguna cadena a
la función.
Serverless Project Structure
El asistente de proyectos sin servidor creará un nuevo proyecto de Eclipse, que se compone de las
siguientes partes:
• The src directory contains two sub-directories, each prefaced with your chosen Package namespace:
mynamespace.function
Contains class files for the Lambda functions that are defined by your serverless template.
mynamespace.model
Contains generic ServerlessInput and ServerlessOutput classes that define the input and
output model for your Lambda functions.
Note
For more information about the input and output formats used in the model classes, see
the Configure Proxy Integration for a Proxy Resource page in the API Gateway Developer
Guide.
• The serverless.template file defines the AWS resources and Lambda functions (a resource of type
“AWS::Serverless:Function”) used by your project.
Deploying a Serverless Project
Para implementar un proyecto sin servidor
1. En la ventana Project Explorer (Explorador de proyectos) de Eclipse, seleccione un proyecto y abra el
menú contextual (haga clic con el botón derecho o mantenga pulsado).
2. Elija Amazon Web Services ‣ Deploy Serverless Project... (Amazon Web Services ‣ Implementar
proyecto sin servidor...) en el menú contextual. Esto abrirá el cuadro de diálogo Deploy Serverless to
AWS CloudFormation.
3. Seleccione los valores de AWS Regions que desea utilizar. Esto determina la ubicación en la que se
encuentra la pila de AWS CloudFormation que se ha implementado.
4. Elija un valor de S3 Bucket para almacenar el código de la función de Lambda en él o seleccione el
botón Create para crear un nuevo bucket de S3 para almacenar el código.
5. Elija un nombre para su pila de AWS CloudFormation.
6. Pulse el botón Finish para cargar sus funciones de Lambda en Amazon S3 e implementar la plantilla
de proyecto en AWS CloudFormation.
13AWS Toolkit for Eclipse Guía del usuario
See Also
The serverless project deployment dialog
Cuando se implementa el proyecto, aparece una ventana de detalles de la pila de AWS CloudFormation
que proporciona información acerca de la implementación y su estado actual. Inicialmente mostrará su
estado como CREATE_IN_PROGRESS. Cuando el estado es CREATE_COMPLETE, su implementación está
activa.
Para volver a esta ventana en cualquier momento, abra AWS Explorer, seleccione el nodo AWS
CloudFormation y, a continuación, seleccione el nombre de la pila de AWS CloudFormation que ha
especificado.
Note
Si se ha producido un error durante la implementación, la pila se puede revertir. Consulte
Troubleshooting en la AWS CloudFormation User Guide para obtener información acerca del
modo de diagnosticar los errores de implementación de la pila.
See Also
• AWS Serverless Application Model (GitHub)
• The AWS CloudFormation Template Editor (p. 38)
• Using Lambda with the AWS Toolkit for Eclipse (p. 21)
14AWS Toolkit for Eclipse Guía del usuario
Differentiating AWS Resources with Naming
Differentiating AWS Resources with Naming
Durante el desarrollo de nuevos productos o características, resulta útil mantener los recursos de AWS
que se usan para el desarrollo separados de los recursos que se utilizan para la producción. Una de
las estrategias para mantener esta separación se trató en Configuración de credenciales de AWS (p. 4)
y consiste en utilizar cuentas diferentes para los recursos de desarrollo y producción. Esta estrategia
funciona especialmente bien cuando se utiliza AWS Explorer, ya que AWS Explorer muestra los recursos
en función de las credenciales de la cuenta. En esta sección se describe una estrategia alternativa en la
que se usa una convención de nomenclatura para diferenciar los recursos de desarrollo y de producción y
en la que la compatibilidad con la convención de nomenclatura se implementa en el código.
La idea básica consiste en diferenciar los recursos de AWS, como buckets de Amazon Simple Storage
Service (Amazon S3) o dominios de Amazon SimpleDB, mediante la adición de un valor de cadena
especificado a los nombres de los recursos. Por ejemplo, en lugar de asignar al dominio de Amazon
SimpleDB el nombre "customers", podría asignarle el nombre "customers-dev" si se va a usar en desarrollo
o "customer-prod" si se va a usar en producción. Sin embargo, surge un problema si necesita transferir
el código de desarrollo a la producción. En ese momento, tendría cambiar todas estas cadenas, quizás
por medio de varias operaciones globales de búsqueda y reemplazo, lo que podría ser lento o propenso
a errores. Un método más eficiente sería añadir en el código la compatibilidad con la convención de
nomenclatura.
15AWS Toolkit for Eclipse Guía del usuario
Differentiating AWS Resources with Naming
La clase StageUtils expone el siguiente método.
public static String getResourceSuffixForCurrentStage()
El método getResourceSuffixForCurrentStage devuelve una cadena que se corresponde con la
"fase" del ciclo de vida del software en la que se usa el recurso, como "dev", "beta" o "prod". Esta cadena
se puede añadir a continuación a los identificadores de recursos empleados en el código. Puede utilizar
getResourceSuffixForCurrentStage para construir nombres de recursos. Por ejemplo, el siguiente
método, getTopicName, devuelve un nombre único para un tema de Amazon SNS. Observe cómo
incrusta el valor devuelto por getResourceSuffixForCurrentStage en este nombre.
private String getTopicName (Entry entry) {
return "entry" + StageUtils.getResourceSuffixForCurrentStage() + "-" + entry.getId();
}
16AWS Toolkit for Eclipse Guía del usuario
Differentiating AWS Resources with Naming
El valor devuelto por getResourceSuffixForCurrentStage se obtiene de la propiedad
"application.stage" del sistema de Java. Puede especificar este valor mediante el ajuste de la propiedad del
sistema en la configuración del contenedor de AWS Elastic Beanstalk.
Note
En AWS Toolkit for Eclipse, la aplicación de AWS Elastic Beanstalk debe estar funcionando
para que se pueda tener acceso a la configuración del contenedor. Al modificar y guardar la
configuración, la aplicación se reinicia automáticamente con la nueva configuración.
To access the Container/JVM Options panel for your AWS Elastic Beanstalk application
1. En AWS Explorer, expanda el nodo AWS Elastic Beanstalk y el nodo de su aplicación.
2. Bajo el nodo de la aplicación, haga doble clic en su entorno de AWS Elastic Beanstalk.
3. En la parte inferior del panel Overview (Información general), haga clic en la pestaña Configuration
(Configuración).
4. En el área Container, configure las opciones de contenedor.
5. En el cuadro Additional Tomcat JVM command line options, especifique el valor de la propiedad del
sistema application.stage añadiendo una opción de línea de comando -D. Por ejemplo, puede utilizar la
siguiente sintaxis para especificar que el valor de cadena debe ser "-beta".
-Dapplication.stage=beta
Tenga en cuenta que getResourceSuffixForCurrentStage antepone automáticamente un guion a
cualquier valor de cadena que se especifique.
6. Una vez que haya añadido el valor de la propiedad del sistema, haga clic en el menú File y, a
continuación, haga clic en Save. Eclipse guardará la nueva configuración. La aplicación debería
reiniciarse automáticamente. Puede comprobar el Eventos pestaña—en la parte inferior del editor
Eclipse—para el evento que indica que la nueva configuración se ha implementado correctamente en el
entorno.
7. Una vez que la aplicación se haya reiniciado, expanda el nodo Amazon SimpleDB en AWS Explorer.
Ahora debería poder ver un nuevo conjunto de dominios que utilizan el valor de cadena especificado.
17AWS Toolkit for Eclipse Guía del usuario
Differentiating AWS Resources with Naming
Note
Para obtener más información acerca de la configuración del contenedor, consulte Creating and
Deploying Java Applications on AWS Elastic Beanstalk en la AWS Elastic Beanstalk Developer
Guide.
18AWS Toolkit for Eclipse Guía del usuario
How to Access AWS Explorer
Working with AWS Services
AWS Explorer le ofrece una vista de varias instancias de Amazon Web Services y le permite manipularlas
simultáneamente. Esta sección proporciona información acerca de cómo obtener acceso a la vista de AWS
Explorer en Eclipse y cómo utilizarla.
Se presupone que ya ha instalado (p. 3) AWS Toolkit for Eclipse en el sistema.
Temas
• How to Access AWS Explorer (p. 19)
• Using Lambda with the AWS Toolkit for Eclipse (p. 21)
• The AWS CloudFormation Template Editor (p. 38)
• Using DynamoDB with AWS Explorer (p. 47)
• Launch an Amazon EC2 Instance from an Amazon Machine Image (p. 51)
• Managing Security Groups from AWS Explorer (p. 55)
• Viewing and Adding Amazon SNS Notifications (p. 58)
• Connecting to Amazon Relational Database Service (Amazon RDS) (p. 60)
• Identity and Access Management (p. 62)
• Debug Serverless Applications Using AWS SAM Local (p. 77)
How to Access AWS Explorer
Para visualizar AWS Explorer, haga clic en el icono de AWS en la barra de herramientas y seleccione
Show AWS Explorer View.
19AWS Toolkit for Eclipse Guía del usuario
How to Access AWS Explorer
AWS Icon Menu
Note
Si el icono de AWS no está visible en la barra de herramientas, haga clic en el menú Window y, a
continuación, haga clic en Open Perspective | Other. Haga clic en AWS Management en la lista de
perspectivas de Eclipse.
Puede expandir cada nodo de AWS Explorer para ver los recursos de AWS que están asociados con su
cuenta. Por ejemplo, si hace clic en el triángulo blanco situado a la izquierda del nodo Amazon EC2, se
expandirá y mostrará los recursos de Amazon EC2 asociados con su cuenta de AWS. AWS Toolkit for
Eclipse utiliza la cuenta de AWS que ha configurado en Set up AWS Credentials (p. 4) para determinar qué
recursos se deben mostrar.
20AWS Toolkit for Eclipse Guía del usuario
Using Lambda with the AWS Toolkit for Eclipse
Si selecciona cualquiera de los subnodes de Amazon EC2, Eclipse abrirá una vista con información
detallada acerca de esos recursos. Por ejemplo, al hacer doble clic en Instances, se abre una vista que
muestra información sobre cada una de las instancias Amazon EC2, como su nombre de DNS público, su
zona de disponibilidad y la hora de lanzamiento.
Using Lambda with the AWS Toolkit for Eclipse
AWS Toolkit for Eclipse ofrece soporte para crear código para AWS Lambda. Lambda es un servicio de
computación completamente administrado que ejecuta su código como respuesta a eventos generados por
código personalizado o de varios servicios de AWS como Amazon S3, DynamoDB, Kinesis, Amazon SNS
y Amazon Cognito. Para obtener más información acerca de Lambda, consulte la AWS Lambda Developer
Guide.
Esta sección de la AWS Toolkit for Eclipse User Guide se centra en cómo se pueden utilizar las
características de AWS Toolkit for Eclipse para crear, implementar y ejecutar funciones de Lambda.
Temas
• Tutorial: How to Create, Upload, and Invoke an AWS Lambda Function (p. 22)
• AWS Lambda Interface Reference (p. 31)
21AWS Toolkit for Eclipse Guía del usuario
Tutorial: How to Create, Upload, and
Invoke an AWS Lambda Function
Tutorial: How to Create, Upload, and Invoke an AWS
Lambda Function
Este tutorial le guía a través del proceso de un flujo de trabajo típico de AWS Lambda y le proporciona una
experiencia de primera mano en el uso de Lambda con AWS Toolkit for Eclipse.
Important
El tutorial presupone que tiene una cuenta de AWS, que ya ha instalado el AWS Toolkit for
Eclipse (p. 3) y que conoce las características y los conceptos básicos de Lambda. Si no está
familiarizado con Lambda, puede obtener más información en la página de inicio de Lambda y en
la Guía para desarrolladores de AWS Lambda.
Create an AWS Lambda Project
Para iniciar un proyecto de Lambda, en primer lugar implemente el código como un método en una clase
de controlador. AWS Toolkit for Eclipse proporciona un nuevo asistente de proyectos para ayudarle a
crear una nueva clase de controlador. El proyecto de Lambda es un proyecto de Maven que utiliza un
archivo POM.xml para administrar las dependencias del paquete. Puede utilizar la herramienta de línea de
comandos Maven para la compilar, probar e implementar una aplicación. Para obtener más información
sobre Maven, consulte la documentación del proyecto Maven.
Para crear un proyecto de AWS Lambda
1. En la barra de herramientas de Eclipse, abra el menú de Amazon Web Services (identificado por el
icono de la página de inicio de AWS) y, a continuación, elija New AWS Lambda Java project. O bien,
en la barra de menús de Eclipse, elija File, New, AWS Lambda Java Project.
2. Añadir un Project name, , Group ID, , Artifact ID, y class name en las cajas de entrada asociadas. El ID
de grupo y el ID de artefacto son los ID que identifican un artefacto de compilación de Maven. En este
tutorial se utilizan los siguientes valores de ejemplo:
• Project name: HelloLambda
• Group ID: com.example.lambda
• Artifact ID: demo
• Class name: Hello
El campo Package Name contiene el espacio de nombres del paquete para la clase de controlador de
AWS Lambda. El valor predeterminado de este campo es una concatenación del ID de grupo y el ID
de artefacto, de acuerdo con las convenciones de los proyectos de Maven. Este campo se actualiza
automáticamente cuando se actualizan los campos Group ID y Artifact ID.
3. En Input Type, elija Custom. Para obtener más información acerca de cada uno de los tipos de
entrada disponibles, consulte New AWS Lambda Java Project Dialog (p. 31).
4. Compruebe que las entradas tienen un aspecto parecido al de la siguiente captura de pantalla
(modifíquelas si no es así) y, a continuación, elija Finish.
22AWS Toolkit for Eclipse Guía del usuario
Tutorial: How to Create, Upload, and
Invoke an AWS Lambda Function
A medida que se escribe, el código de Source preview cambia para reflejar los cambios realizados en
el cuadro de diálogo.
5. Cuando elija Finish (Finalizar), se generará el directorio y los archivos de código fuente del
proyecto en el workspace de Eclipse. Se abre una nueva ventana del navegador web, que muestra
README.html (que se creó para usted en el directorio raíz de proyecto). README.html proporciona
instrucciones que le guiarán a través de los siguientes pasos de la implementación, las pruebas, la
carga y la invocación de la nueva función de Lambda. Lea el documento para familiarizarse con los
siguientes pasos que se describen aquí.
23AWS Toolkit for Eclipse Guía del usuario
Tutorial: How to Create, Upload, and
Invoke an AWS Lambda Function
A continuación, implemente la función en el proyecto de Java HelloLambda que se acaba de crear en
Eclipse.
Implement the Handler Method
Puede utilizar el cuadro de diálogo Create New Project para crear la estructura de un proyecto. Ahora
rellene el código que se ejecutará cuando se invoque la función de Lambda. (En este caso, a través de un
evento personalizado que envía una cadena a la función, tal y como especificó al configurar el parámetro
de entrada del método).
Para implementar el método de controlador de Lambda
1. En Eclipse, en Project Explorer, abra Hello.java en el proyecto HelloLambda. Contendrá un código
similar al siguiente.
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. Reemplace el contenido de la función handleRequest con el siguiente código.
@Override
public String handleRequest(String input, Context context) {
context.getLogger().log("Input: " + input);
String output = "Hello, " + input + "!";
return output;
}
Allow Lambda to Assume an IAM Role
Para que Lambda pueda tener acceso a la función de Lambda, tiene que crear un rol de IAM que le
conceda acceso a sus recursos de AWS. Puede crear el rol de dos maneras: a través de la Consola de
administración de AWS o mediante AWS Toolkit for Eclipse. En esta sección se describe cómo crear el
rol de IAM en la consola. Consulte Carga del código (p. 25) para crear uno utilizando AWS Toolkit for
Eclipse.
Para crear un rol de IAM para Lambda
1. Inicie sesión en la Consola de administración de AWS.
2. En el menú Services, abra la consola de IAM.
3. En el panel de navegación, elija Roles y, a continuación, Create role.
4. En Select type of trusted entity, elija AWS service y, a continuación, elija Lambda para el servicio que
utilizará este rol. A continuación, elija Next (Siguiente). Permissions (Permisos)
24AWS Toolkit for Eclipse Guía del usuario
Tutorial: How to Create, Upload, and
Invoke an AWS Lambda Function
5. En Attach permissions policy, elija AWSLambdaBasicExecutionRole. Esto permite que Lambda
escriba en los recursos de registros de CloudWatch. A continuación, elija Next (Siguiente). Review
(Revisar)
6. Añada un nombre para el rol, por ejemplo, hello-lambda-role y una descripción. A continuación,
elija Create role para finalizar la creación del rol de IAM.
Create an Amazon S3 Bucket for Your Lambda Code
AWS Lambda requiere un bucket de Amazon S3 para almacenar su proyecto de Java cuando lo cargue.
Puede utilizar un bucket que ya exista en la región de AWS en la que se va a ejecutar el código o puede
crear uno nuevo específicamente para que Lambda lo utilice (opción recomendada).
Puede crear un bucket de Amazon S3 de dos maneras, a través de la Consola de administración de AWS
o mediante AWS Toolkit for Eclipse. En esta sección se describe cómo crear un bucket de Amazon S3 en
la consola. Consulte Carga del código (p. 25) para crear uno utilizando AWS Toolkit for Eclipse.
Para crear un bucket de Amazon S3 para su uso con Lambda
1. Inicie sesión en la Consola de administración de AWS.
2. En el menú Services, abra la consola de S3.
3. Elija Create bucket (Crear bucket).
4. Escriba un nombre y una región para el bucket. Esta región debe ser la misma en la que desea
ejecutar la función de Lambda. Para obtener una lista de las regiones admitidas por Lambda, consulte
Regiones y puntos de enlace en la Amazon Web Services General Reference.
5. Elija Create para terminar de crear el bucket.
Upload the Code
A continuación, debe cargar el código en AWS Lambda como preparación para invocarlo desde la Consola
de administración de AWS.
Para cargar la función en Lambda
1. Haga clic con el botón derecho en la ventana de código de Eclipse, elija AWS Lambda y, a
continuación, elija Upload function to AWS Lambda.
2. En la página Select Target Lambda Function, elija la región de AWS que desea utilizar. Debe ser la
misma región que eligió para el bucket de Amazon S3 (p. 25).
25AWS Toolkit for Eclipse Guía del usuario
Tutorial: How to Create, Upload, and
Invoke an AWS Lambda Function
3. Elija Create a new Lambda function y, a continuación, escriba un nombre para la función (por ejemplo,
HelloFunction).
4. Seleccione Next (Siguiente).
5. En la página Function Configuration, introduzca una descripción para la función de Lambda de destino
y, a continuación, elija el rol IAM y el bucket Amazon S3 que utilizará la función.
26AWS Toolkit for Eclipse Guía del usuario
Tutorial: How to Create, Upload, and
Invoke an AWS Lambda Function
Para obtener más información sobre las opciones disponibles, consulte Cuadro de diálogo Upload
AWS Lambda Function (p. 33).
6. En la página Function Configuration, elija Create en Function Role si desea crear un nuevo rol de IAM
para la función de Lambda. Introduzca un nombre de rol en el cuadro de diálogo Create Role.
27AWS Toolkit for Eclipse Guía del usuario
Tutorial: How to Create, Upload, and
Invoke an AWS Lambda Function
7. En la página Function Configuration, elija Publish new version si desea que la carga cree una versión
nueva de la función de Lambda. Para obtener más información sobre el control de versiones y los
alias en Lambda, consulte Control de versiones y alias de las funciones de AWS Lambda en la AWS
Lambda Developer Guide.
8. Si optó por publicar una versión nueva, la opción Provide an alias to this new version está habilitada.
Elija esta opción si desea asociar un alias a esta versión de la función de Lambda.
9. En la página Function Configuration, elija Create en la sección S3 Bucket for Function Code si desea
crear un nuevo bucket de Amazon S3 para la función de Lambda. Introduzca un nombre para el
bucket en el cuadro de diálogo Create Bucket.
10. En la sección S3 Bucket for Function Code, también puede indicar que desea cifrar el código que
se va a cargar. En este ejemplo, deje seleccionada la opción None. Para obtener más información
sobre el cifrado de Amazon S3, consulte Protección de datos con el cifrado del lado del servidor en la
Amazon S3 Developer Guide.
11. Deje las opciones de la sección Advanced Settings como están. AWS Toolkit for Eclipse selecciona los
valores predeterminados automáticamente. Elija Finish para cargar la función de Lambda en AWS.
Si la carga se realiza correctamente, verá el nombre de la función de Lambda que eligió, junto al nombre
de la clase de controlador de Java en la vista Project Explorer.
28AWS Toolkit for Eclipse Guía del usuario
Tutorial: How to Create, Upload, and
Invoke an AWS Lambda Function
Si esto no ocurre, abra la vista Error Log (Registro de errores) de Eclipse. Lambda utilizará este registro
de errores para escribir información sobre los problemas al cargar o ejecutar la función y facilitar su
depuración.
Invoke the Lambda Function
Ahora puede invocar la función en AWS Lambda.
Para invocar una función de Lambda
1. Haga clic con el botón derecho en la ventana de código de Eclipse, elija AWS Lambda y, a
continuación, elija Run Function on AWS Lambda.
2. Elija la clase de controlador que desea invocar.
3. En el cuadro de entrada, escriba una cadena JSON válida, como "AWS Lambda".
29AWS Toolkit for Eclipse Guía del usuario
Tutorial: How to Create, Upload, and
Invoke an AWS Lambda Function
Note
Puede añadir archivos de entrada JSON al proyecto; en este cuadro de diálogo, se mostrarán
aquellos cuyo nombre termine por .json. Puede utilizar esta característica para proporcionar
archivos de entrada estándar para las funciones de Lambda.
4. La casilla Show Live Log está activada de forma predeterminada, por lo que se muestran los logs de la
salida de la función de Lambda en la consola de Eclipse.
5. Elija Invoke para enviar los datos de entrada a la función de Lambda. Si todo está configurado
correctamente, el valor de retorno de la función debería aparecer en la vista Console (Consola) de
Eclipse (que se abrirá automáticamente si aún no lo ha hecho).
Enhorabuena, acaba de ejecutar su primera función Lambda directamente desde el IDE de Eclipse.
Next Steps
Ahora que ha cargado e implementado la función, pruebe a cambiar el código y a ejecutarla de nuevo.
Lambda vuelve a cargarse automáticamente, invoca la función por usted y después muestra la salida en la
consola de Eclipse.
30AWS Toolkit for Eclipse Guía del usuario
AWS Lambda Interface Reference
More Info
Para obtener más información sobre cada una de las páginas que se han descrito en este tutorial,
así como una descripción completa de cada opción, consulte la Referencia de la interfaz de AWS
Lambda (p. 31).
Para obtener más información sobre Lambda y sobre cómo escribir código Java para Lambda, consulte
Creación de funciones de Lambda en Java en la AWS Lambda Developer Guide.
AWS Lambda Interface Reference
Esta sección proporciona información detallada acerca de cada uno de los elementos de la interfaz
añadidos a Eclipse por AWS Toolkit for Eclipse para AWS Lambda.
Temas
• New AWS Lambda Java Project Dialog (p. 31)
• Upload Function to AWS Lambda Dialog Box (p. 33)
• Run AWS Lambda Function Dialog (p. 37)
New AWS Lambda Java Project Dialog
El cuadro de diálogo New Lambda Java Project le ayuda a crear y configurar un nuevo proyecto de Java
que puede utilizar para crear una función de Lambda.
Launching the dialog
El cuadro de diálogo New Lambda Java Project se puede lanzar de las siguientes formas:
• by opening the AWS menu in the Eclipse toolbar and selecting New AWS Lambda Java project….
• by selecting File ‣ New ‣ Other… in the Eclipse menu, and then choosing AWS ‣ AWS Lambda Java
Project in the resulting dialog.
31You can also read
