Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Introducción a AWS SDK para Java 2.x En las secciones de este tema se explican los pasos esenciales para empezar a crear aplicaciones de Java que puedan conectarse a Servicio de AWS. En las secciones se describe la configuración del entorno de desarrollo con Java y la creación de herramientas como Maven o Gradle, la configuración de autenticación segura en AWS y la creación de una primera aplicación funcional mediante un tutorial práctico. Este tema apto para principiantes le servirá de punto de partida al desarrollo de AWS con Java y le proporcionará la base que necesitará para explorar características más avanzadas. **Contents** + [Configuración de AWS SDK para Java 2.x](setup.md) + [Descripción general de la configuración](setup.md#setup-overview) + [Instale Java y una herramienta de compilación para trabajar con AWS SDK for Java 2.x](setup-java-buildtool.md) + [Configure un proyecto de Apache Maven que utilice AWS SDK for Java 2.x](setup-project-maven.md) + [Requisitos previos](setup-project-maven.md#prerequisitesmaven) + [Crear un proyecto de Maven](setup-project-maven.md#create-maven-project) + [Configurar el compilador Java para Maven](setup-project-maven.md#configure-maven-compiler) + [Declarar el SDK como una dependencia](setup-project-maven.md#sdk-as-dependency) + [Establecer dependencias para módulos del SDK](setup-project-maven.md#modules-dependencies) + [Crear todo el SDK en su proyecto](setup-project-maven.md#build-the-entire-sdk-into-your-project) + [Compilación del proyecto](setup-project-maven.md#build-project) + [Configura un proyecto de Gradle que utilice AWS SDK for Java 2.x](setup-project-gradle.md) + [Configure un proyecto de GraalVM Native Image que utilice AWS SDK for Java 2.x](setup-project-graalvm.md) + [Requisitos previos](setup-project-graalvm.md#setup-graalvmnativeimage-prereq) + [Crear un proyecto mediante el arquetipo](setup-project-graalvm.md#setup-graalvmnativeimage-project) + [Crear una imagen nativa](setup-project-graalvm.md#build-graalvmnativeimage-project) + [Autenticación AWS mediante el uso del AWS SDK for Java 2.x](get-started-auth.md) + [Configuración de la autenticación](get-started-auth.md#setup-auth) + [1. Desarrollo local con credenciales a corto plazo](get-started-auth.md#setup-login) + [2. Configuración del acceso de inicio de sesión único para el SDK](get-started-auth.md#setup-credentials) + [3. Inicie sesión con el AWS CLI](get-started-auth.md#setup-login-sso) + [Opciones de autenticación adicionales](get-started-auth.md#setup-additional) + [Creación de una aplicación sencilla mediante el AWS SDK for Java 2.x](get-started-tutorial.md) + [Paso 1: Configuración para este tutorial](get-started-tutorial.md#get-started-setup) + [Paso 2: Crear el proyecto](get-started-tutorial.md#get-started-projectsetup) + [Paso 3: Escribir el código](get-started-tutorial.md#get-started-code) + [Paso 4: Compilar y ejecutar la aplicación](get-started-tutorial.md#get-started-run) + [Success](get-started-tutorial.md#get-started-success) + [Limpieza](get-started-tutorial.md#cleanup) + [Siguientes pasos](get-started-tutorial.md#get-started-next) # Configuración de AWS SDK para Java 2.x En esta sección se ofrece información sobre cómo configurar su entorno de desarrollo y proyectos para utilizar el AWS SDK for Java 2.x. ## Descripción general de la configuración Para desarrollar con éxito aplicaciones que accedan a Servicios de AWS utilizando el AWS SDK para Java, se requieren las siguientes condiciones: + El SDK de Java debe tener acceso a las credenciales para [autenticar solicitudes](get-started-auth.md#setup-auth) en su nombre. + Los [permisos del rol de IAM](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html) configurados para el SDK deben permitir el acceso a los Servicios de AWS que requiera su aplicación. Los permisos asociados a la política administrada de AWS **PowerUserAccess** son suficientes para la mayoría de las necesidades de desarrollo. + Un entorno de desarrollo con los siguientes elementos: + [Archivos de configuración compartidos](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) que se configuran al menos de una de las siguientes maneras: + El archivo `config` contiene la [configuración de inicio de sesión único del IAM Identity Center](get-started-auth.md#setup-credentials) para que el SDK pueda obtener las credenciales AWS. + El archivo `credentials` contiene credenciales temporales. + Una [instalación de Java 8](setup-java-buildtool.md) o posterior. + Una [herramienta de automatización de compilaciones](setup-java-buildtool.md), como [Maven](https://maven.apache.org/download.cgi) o [Gradle](https://gradle.org/install/). + Un editor de texto para trabajar con código. + (Opcional, pero recomendado) Un IDE (entorno de desarrollo integrado) como [IntelliJ IDEA](https://www.jetbrains.com/idea/download/#section=windows) [Eclipse](https://www.eclipse.org/ide/) o [NetBeans.](https://netbeans.apache.org/front/main/download/index.html) Si utiliza IntelliJ IDEA, también puede añadir [AWS Toolkit para IntelliJ IDEA](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html) para integrar Servicios de AWS directamente en el IDE y ayudar a agilizar el desarrollo. + Una sesión activa del portal de acceso a la AWS cuando esté listo para ejecutar su aplicación. Utiliza AWS Command Line Interface para [el proceso de inicio de sesión](get-started-auth.md#setup-login-sso) en el portal de acceso a AWS del Centro de identidad de IAM. **importante** En las instrucciones de esta sección de configuración se supone que usted o su organización utilizan el Centro de identidad de IAM. Si su organización utiliza un proveedor de identidad externo que funciona de forma independiente del Centro de identidades de IAM, averigüe cómo puede obtener credenciales temporales para que las utilice el SDK para Java. Siga [estas instrucciones](credentials-temporary.md#credentials-temporary-from-portal) para añadir credenciales temporales al archivo `~/.aws/credentials`. Si su proveedor de identidad agrega credenciales temporales automáticamente al archivo `~/.aws/credentials`, asegúrese de que el nombre del perfil sea `[default]` para que no necesite proporcionarlo al SDK o AWS CLI. # Instale Java y una herramienta de compilación para trabajar con AWS SDK for Java 2.x Debe cumplir los siguientes requisitos de entorno de desarrollo para trabajar con SDK para Java 2.x: + Java 8 o posterior AWS SDK para Java [Funciona con el [kit de desarrollo Java SE de Oracle](https://www.oracle.com/java/technologies/downloads/) y con distribuciones del Open Java Development Kit (OpenJDK) [Amazon Corretto](https://aws.amazon.com/corretto/), como [Red Hat OpenJDK](https://developers.redhat.com/products/openjdk/overview) y Adoptium.](https://adoptium.net/) + Una herramienta de compilación compatible con Maven como Apache Maven, Apache Ant with Ivy, Gradle o IntelliJ. + [Para obtener información sobre cómo instalar y usar Maven, consulte https://maven.apache.org/.](https://maven.apache.org/) + Para obtener información sobre cómo instalar y utilizar Apache Ivy, consulte [https://ant.apache.org/ivy/](https://ant.apache.org/ivy/). + Para obtener información sobre cómo instalar y usar Gradle, consulte [https://gradle.org/](https://gradle.org/). + Para obtener información sobre cómo instalar y utilizar IntelliJ IDEA, consulte. [https://www.jetbrains.com/idea/](https://www.jetbrains.com/idea/) # Configure un proyecto de Apache Maven que utilice AWS SDK for Java 2.x Puede utilizar [Apache Maven](https://maven.apache.org/) para configurar y compilar proyectos de AWS SDK for Java 2.x o para [compilar el propio SDK](https://github.com/aws/aws-sdk-java-v2/tree/master#building-from-source). ## Requisitos previos Para usar el SDK para Java 2.x con Maven necesita lo siguiente: + Java *8.0 o posterior*. Puede descargar la versión más reciente del software Java SE Development Kit desde [http://www.oracle. com/technetwork/java/javase/downloads](https://www.oracle.com/java/technologies/downloads/)/. El SDK para Java 2.x también funciona con [OpenJDK](https://openjdk.org/) Amazon Corretto y con una distribución del Open Java Development Kit (OpenJDK). Descargue la última versión de OpenJDK desde. [https://openjdk.java.net/install/index.html](https://openjdk.org/install/index.html) Descargue la última versión Amazon Corretto 8 u Amazon Corretto 11 de [la Corretto](https://aws.amazon.com/corretto/) página. + *Apache Maven*. Si necesita instalar Maven, vaya a [http://maven.apache.org/](https://maven.apache.org/) para descargarlo e instalarlo. ## Crear un proyecto de Maven Para crear un proyecto Maven desde la línea de comandos, ejecute el siguiente comando desde un terminal o una ventana del indicador de comandos.```` ``` mvn -B archetype:generate \ -DarchetypeGroupId=software.amazon.awssdk \ -DarchetypeArtifactId=archetype-lambda -Dservice=s3 -Dregion=US_WEST_2 \ -DarchetypeVersion=2.X.X \ -DgroupId=com.example.myapp \ -DartifactId=myapp ``` **nota** Sustituya *com.example.myapp* por el espacio de nombres del paquete completo de su aplicación. Sustituya también *myapp* por el nombre de su proyecto. Esto se convierte en el nombre del directorio del proyecto. Para usar la última versión del arquetipo, sustitúyala por *2.X.X* la [última de Maven Central](https://central.sonatype.com/artifact/software.amazon.awssdk/archetype-lambda). Este comando crea un proyecto Maven utilizando el conjunto de herramientas de plantillas de arquetipos. El arquetipo genera el andamiaje para un proyecto de gestión de funciones. AWS Lambda Este arquetipo de proyecto está preconfigurado para compilar con Java SE 8 e incluye una dependencia a la versión del SDK para Java 2.x especificada con `-DarchetypeVersion`. Para obtener más información sobre cómo crear y configurar proyectos de Maven, consulte [Maven Getting Started Guide](https://maven.apache.org/guides/getting-started/). ## Configurar el compilador Java para Maven Si ha creado su proyecto utilizando el arquetipo del AWS Lambda proyecto tal y como se ha descrito anteriormente, la configuración del compilador de Java ya está hecha. Para comprobar que esta configuración está presente, comience abriendo el archivo `pom.xml` desde la carpeta de proyecto que creó (por ejemplo, `myapp`) cuando ejecutó el comando anterior. Busque en las líneas 11 y 12 para consultar la configuración de la versión del compilador Java para este proyecto de Maven y la inclusión requerida del complemento del compilador de Maven en las líneas 71-75. ``` 1.8 1.8 org.apache.maven.plugins maven-compiler-plugin ${maven.compiler.plugin.version} ``` Si crea su proyecto con un arquetipo diferente o utilizando otro método, debe asegurarse de que el complemento del compilador de Maven sea parte de la compilación y que sus propiedades de origen y destino están establecidas en **1.8** en el archivo `pom.xml`. Consulte el fragmento anterior para ver una forma de configurar estos parámetros necesarios. Otra opción sería definir la configuración del compilador insertada con la declaración del complemento, de la siguiente manera. ``` org.apache.maven.plugins maven-compiler-plugin 1.8 1.8 ``` ## Declarar el SDK como una dependencia Para usarlo AWS SDK para Java en su proyecto, debe declararlo como una dependencia en el archivo de su proyecto. `pom.xml` Si creó su proyecto utilizando el arquetipo de proyecto como se describió anteriormente, la última versión del SDK ya está configurada como una dependencia en su proyecto. El arquetipo genera un artefacto dependiente de la BOM (lista de materiales) para el identificador del grupo `software.amazon.awssdk`. Con una lista de materiales, no tiene que especificar la versión de Maven para las dependencias de artefactos individuales que comparten el mismo id de grupo. Si creó su proyecto de Maven de otra manera, configure la versión más reciente del SDK para su proyecto asegurándose de que el archivo `pom.xml` contenga lo siguiente. ``` 2.X.X software.amazon.awssdk bom ${aws.java.sdk.version} pom import ``` **nota** Sustitúyala *2.X.X* en el `pom.xml` archivo por la [última versión de AWS SDK for Java 2.x](https://central.sonatype.com/artifact/software.amazon.awssdk/bom). ## Establecer dependencias para módulos del SDK Ahora que ha configurado el SDK, puede añadir dependencias para uno o más de los AWS SDK para Java módulos para utilizarlos en su proyecto. Aunque puede especificar el número de versión para cada componente, no es necesario porque ya declaró la versión del SDK en la sección `dependencyManagement` usando la lista de materiales. Para cargar una versión personalizada de un módulo determinado, especifique un número de versión para su dependencia. Si creó su proyecto utilizando el arquetipo de proyecto como se ha descrito anteriormente, su proyecto ya está configurado con múltiples dependencias. Incluyen las dependencias de los controladores de funciones AWS Lambda y Amazon S3, de la siguiente manera. ``` software.amazon.awssdk s3 software.amazon.awssdk netty-nio-client software.amazon.awssdk apache-client software.amazon.awssdk url-connection-client com.amazonaws aws-lambda-java-core ${aws.lambda.java.version} ``` **nota** En el ejemplo `pom.xml` anterior, las dependencias son de diferentes `groupId`. La dependencia `s3` es de `software.amazon.awssdk`, mientras que la dependencia `aws-lambda-java-core` es de `com.amazonaws`. La configuración de administración de dependencias de la BOM afecta a los artefactos para `software.amazon.awssdk`, por lo que se necesita una versión para el artefacto `aws-lambda-java-core`. Para el desarrollo de *controladores de funciones Lambda* utilizando el SDK para Java 2.x, `aws-lambda-java-core` es la dependencia correcta. Sin embargo, si la aplicación necesita administrar los recursos de Lambda, el uso de operaciones como `listFunctions`, `deleteFunction`, `invokeFunction` y `createFunction`, la aplicación requiere la siguiente dependencia. ``` software.amazon.awssdk lambda ``` **nota** La dependencia `s3` excluye las dependencias transitivas `netty-nio-client` y `apache-client`. En lugar de cualquiera de esos clientes HTTP, el arquetipo incluye la dependencia `url-connection-client`, lo que ayuda a [reducir la latencia de inicio de las funciones de AWS Lambda](lambda-optimize-starttime.md#lambda-quick-url). Agregue los módulos a su proyecto para obtener las funciones Servicio de AWS y características que necesite para su proyecto. Los módulos (dependencias) que administra la BOM de AWS SDK para Java se enumeran en el [repositorio central de Maven.](https://central.sonatype.com/artifact/software.amazon.awssdk/bom) **nota** Puede examinar el archivo `pom.xml` de un ejemplo de código para determinar qué dependencias necesita para su proyecto. [Por ejemplo, si le interesan las dependencias del servicio DynamoDB, [consulte este](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/dynamodb/pom.xml) ejemplo del repositorio de ejemplos de AWS código en.](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2) GitHub (Busque el archivo `pom.xml` en [/java2/example\$1code/dynamodb](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/dynamodb).) ### Crear todo el SDK en su proyecto Para optimizar su aplicación, le recomendamos encarecidamente que extraiga solo los componentes que necesita en lugar de todo el SDK. Sin embargo, para integrarlo todo AWS SDK para Java en el proyecto, declárelo en el `pom.xml` archivo de la siguiente manera. ``` software.amazon.awssdk aws-sdk-java 2.X.X ``` ## Compilación del proyecto Después de configurar el archivo `pom.xml`, puede usar Maven para crear el proyecto. Para crear el proyecto de Maven desde la línea de comandos, abra una ventana de terminal o símbolo del sistema, desplácese hasta el directorio del proyecto (por ejemplo, `myapp`), escriba o pegue el siguiente comando y, a continuación, presione "Enter" o "Return". ``` mvn package ``` Esto crea un único archivo `.jar` (JAR) en el directorio `target` (por ejemplo, `myapp/target`). Este JAR contiene todos los módulos del SDK especificados como dependencias en su archivo `pom.xml`. # Configura un proyecto de Gradle que utilice AWS SDK for Java 2.x Puede usar [Gradle](https://gradle.org/) para configurar y crear proyectos AWS SDK for Java 2.x . Los pasos iniciales del ejemplo siguiente provienen de la [Guía de introducción de Gradle](https://docs.gradle.org/current/samples/sample_building_java_applications.html) para la versión 8.4. Si usa una versión diferente, los resultados pueden diferir ligeramente. **Para crear una aplicación Java con Gradle (línea de comandos)** 1. Cree un directorio para alojar su proyecto. En este ejemplo, el directorio se llama `demo`. 1. En el directorio `demo`, ejecute el comando `gradle init` y proporcione los valores resaltados en rojo, como se muestra en el siguiente resultado de la línea de comandos. Para explicarlo, elegimos Kotlin como lenguaje DSL para compilar scripts, pero al final de este tema también se muestra un ejemplo completo de Groovy. ``` > gradle init Starting a Gradle Daemon (subsequent builds will be faster) Select type of project to generate: 1: basic 2: application 3: library 4: Gradle plugin Enter selection (default: basic) [1..4] 2 Select implementation language: 1: C++ 2: Groovy 3: Java 4: Kotlin 5: Scala 6: Swift Enter selection (default: Java) [1..6] 3 Generate multiple subprojects for application? (default: no) [yes, no] no Select build script DSL: 1: Kotlin 2: Groovy Enter selection (default: Kotlin) [1..2] Select test framework: 1: JUnit 4 2: TestNG 3: Spock 4: JUnit Jupiter Enter selection (default: JUnit Jupiter) [1..4] 4 Project name (default: demo): Source package (default: demo): Enter target version of Java (min. 7) (default: 11): Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no] > Task :init To learn more about Gradle by exploring our Samples at https://docs.gradle.org/8.4/samples/sample_building_java_applications.html BUILD SUCCESSFUL in 3m 43s 2 actionable tasks: 2 executed ``` 1. Una vez completada la tarea `init`, el directorio `demo` contiene la siguiente estructura de árbol. En la siguiente sección examinaremos más de cerca el archivo de compilación principal `build.gradle.kts` (resaltado en rojo). ``` ├── app │   ├── build.gradle.kts │   └── src │   ├── main │   │   ├── java │   │   │   └── demo │   │   │   └── App.java │   │   └── resources │   └── test │   ├── java │   │   └── demo │   │   └── AppTest.java │   └── resources ├── gradle │   └── wrapper │   ├── gradle-wrapper.jar │   └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat └── settings.gradle.kts ``` El archivo `build.gradle.kts` contiene el siguiente andamiaje. ``` /* * This file was generated by the Gradle 'init' task. * * This generated file contains a sample Java application project to get you started. * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.4/userguide/building_java_projects.html in the Gradle documentation. */ plugins { // Apply the application plugin to add support for building a CLI application in Java. application } repositories { // Use Maven Central for resolving dependencies. mavenCentral() } dependencies { // Use JUnit Jupiter for testing. testImplementation("org.junit.jupiter:junit-jupiter:5.9.3") testRuntimeOnly("org.junit.platform:junit-platform-launcher") // This dependency is used by the application. implementation("com.google.guava:guava:33.3.0-jre") } // Apply a specific Java toolchain to ease working on different environments. java { toolchain { languageVersion.set(JavaLanguageVersion.of(11)) } } application { // Define the main class for the application. mainClass.set("demo.App") } tasks.named("test") { // Use JUnit Platform for unit tests. useJUnitPlatform() } ``` 1. Usa el archivo de compilación de Gradle estructurado como base para tu proyecto. AWS 1. Para administrar las dependencias del SDK de tu proyecto de Gradle, agrega la lista de materiales (BOM) de Maven correspondiente a la sección del AWS SDK for Java 2.x archivo. `dependencies` `build.gradle.kts` ``` ... dependencies { implementation(platform("software.amazon.awssdk:bom:2.27.21")) // With the bom declared, you specify individual SDK dependencies without a version. ... } ... ``` **nota** En este archivo de compilación de ejemplo, sustituya la *2.27.21* por la última versión del SDK para Java 2.x. Busque la última versión disponible en el [repositorio central de Maven](https://central.sonatype.com/artifact/software.amazon.awssdk/bom/versions). 1. Especifique los módulos del SDK que necesita su aplicación en la sección `dependencies`. A modo de ejemplo, lo siguiente añade una dependencia de Amazon Simple Storage Service. ``` ... dependencies { implementation(platform("software.amazon.awssdk:bom:2.27.21")) implementation("software.amazon.awssdk:s3") ... } ... ``` Gradle resuelve automáticamente la versión correcta de las dependencias del SDK con la información de la BOM. En los siguientes ejemplos, se muestran los archivos de compilación completos de Gradle tanto en Kotlin como en Groovy. DSLs El archivo de compilación contiene las dependencias para Amazon S3, la autenticación, el registro y las pruebas. La versión de origen y destino de Java es la versión 11. ------ #### [ Kotlin DSL (build.gradle.kts) ] ``` /* * This file was generated by the Gradle 'init' task. * * This generated file contains a sample Java application project to get you started. * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.4/userguide/building_java_projects.html in the Gradle documentation. */ plugins { // Apply the application plugin to add support for building a CLI application in Java. application } repositories { // Use Maven Central for resolving dependencies. mavenCentral() } dependencies { implementation(platform("software.amazon.awssdk:bom:2.20.56")) implementation("software.amazon.awssdk:s3") implementation("software.amazon.awssdk:sso") implementation("software.amazon.awssdk:ssooidc") implementation(platform("org.apache.logging.log4j:log4j-bom:2.20.0")) implementation("org.apache.logging.log4j:log4j-slf4j2-impl") implementation("org.apache.logging.log4j:log4j-1.2-api") testImplementation(platform("org.junit:junit-bom:5.10.0")) testImplementation("org.junit.jupiter:junit-jupiter") } // Apply a specific Java toolchain to ease working on different environments. java { toolchain { languageVersion.set(JavaLanguageVersion.of(11)) } } application { // Define the main class for the application. mainClass.set("demo.App") } tasks.named("test") { // Use JUnit Platform for unit tests. useJUnitPlatform() } ``` ------ #### [ Groovy DSL (build.gradle) ] ``` /* * This file was generated by the Gradle 'init' task. * * This generated file contains a sample Java application project to get you started. * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.4/userguide/building_java_projects.html in the Gradle documentation. */ plugins { // Apply the application plugin to add support for building a CLI application in Java. id 'application' } repositories { // Use Maven Central for resolving dependencies. mavenCentral() } dependencies { implementation platform('software.amazon.awssdk:bom:2.27.21') implementation 'software.amazon.awssdk:s3' implementation 'software.amazon.awssdk:sso' implementation 'software.amazon.awssdk:ssooidc' implementation platform('org.apache.logging.log4j:log4j-bom:2.20.0') implementation 'org.apache.logging.log4j:log4j-slf4j2-impl' implementation 'org.apache.logging.log4j:log4j-1.2-api' testImplementation platform('org.junit:junit-bom:5.10.0') testImplementation 'org.junit.jupiter:junit-jupiter' } // Apply a specific Java toolchain to ease working on different environments. java { toolchain { languageVersion = JavaLanguageVersion.of(11) } } application { // Define the main class for the application. mainClass = 'demo_groovy.App' } tasks.named('test') { // Use JUnit Platform for unit tests. useJUnitPlatform() } ``` ------ Para ver los pasos siguientes, consulte la guía de introducción en el sitio web de Gradle para obtener instrucciones sobre cómo [compilar y ejecutar una aplicación de Gradle](https://docs.gradle.org/current/samples/sample_building_java_applications.html#run_the_application). # Configure un proyecto de GraalVM Native Image que utilice AWS SDK for Java 2.x Con las versiones 2.16.1 y posteriores, AWS SDK for Java 2.x proporciona out-of-the-box soporte para las aplicaciones GraalVM Native Image. Utilice el arquetipo de `archetype-app-quickstart` Maven para configurar un proyecto con soporte de imágenes nativo integrado. ## Requisitos previos + Complete los pasos que se indican en [Configuración](setup.md) de la versión 2.x. AWS SDK para Java + Instalar [GraalVM Native Image](https://www.graalvm.org/reference-manual/native-image/#install-native-image). ## Crear un proyecto mediante el arquetipo Para crear un proyecto de Maven con soporte de imágenes nativo integrado, utilice el siguiente comando en una ventana de terminal o línea de comandos. **nota** Sustituya `com.example.mynativeimageapp` por el espacio de nombres completo del paquete de su aplicación. Sustituya también `mynativeimageapp` por el nombre de su proyecto. Esto se convierte en el nombre del directorio del proyecto. ``` mvn archetype:generate \ -DarchetypeGroupId=software.amazon.awssdk \ -DarchetypeArtifactId=archetype-app-quickstart \ -DarchetypeVersion=2.27.21\ -DnativeImage=true \ -DhttpClient=apache-client \ -Dservice=s3 \ -DgroupId=com.example.mynativeimageapp \ -DartifactId=mynativeimageapp \ -DinteractiveMode=false ``` Este comando crea un proyecto de Maven configurado con dependencias para el AWS SDK para Java Amazon S3, y el `ApacheHttpClient` cliente HTTP. También incluye una dependencia para el [complemento GraalVM Native Image Maven](https://graalvm.github.io/native-build-tools/latest/index.html), para que pueda crear imágenes nativas con Maven. Para incluir las dependencias de otro servicio Amazon Web Services, establezca el valor del `-Dservice` parámetro en el ID de artefacto de ese servicio. Entre los ejemplos se incluyen `dynamodb`, `comprehend` y `pinpoint`. Para obtener una lista completa de los artefactos IDs, consulta la lista de dependencias administradas de [software.amazon.awssdk](https://mvnrepository.com/artifact/software.amazon.awssdk/bom/latest) en Maven Central. Para usar un cliente HTTP asíncrono, defina el parámetro `-DhttpClient` como `netty-nio-client`. Para usar `UrlConnectionHttpClient` como cliente HTTP asíncrono en lugar de `apache-client`, defina el parámetro `-DhttpClient` en `url-connection-client`. ## Crear una imagen nativa Tras crear el proyecto, ejecute el siguiente comando desde el directorio del proyecto, por ejemplo `mynativeimageapp`: ``` mvn package -P native-image ``` Esto crea una aplicación de imagen nativa en el directorio `target`, por ejemplo, `target/mynativeimageapp`. # Autenticación AWS mediante el uso del AWS SDK for Java 2.x Debe establecer cómo se AWS SDK for Java 2.x autentica AWS cuando desarrolla con AWS los servicios. El SDK administra la detección de credenciales, la creación de firmas y la actualización de credenciales totalmente en segundo plano, lo que le permite centrarse en la lógica de la aplicación. ## Configuración de la autenticación El tema sobre [autenticación y acceso](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) de la Guía de referencia sobre herramientas AWS SDKs y herramientas describe los diferentes enfoques de autenticación. Para el desarrollo local, el enfoque recomendado es utilizar credenciales a corto plazo iniciando sesión en la AWS CLI con las credenciales de inicio de sesión de la consola. Se recomienda utilizar usuarios root, usuarios de IAM o estar federados con IAM para acceder a la AWS cuenta. Siga las instrucciones de [Acceda a las credenciales para el trabajo de desarrollo interactivo mediante AWS SDK for Java 2.x](credentials-temporary.md). Tras seguir las instrucciones AWS SDKs y la Guía de referencia de herramientas, tu sistema debería estar configurado para permitir que el SDK firme las solicitudes: ### 1. Desarrollo local con credenciales a corto plazo Para el desarrollo local, el enfoque recomendado es utilizar credenciales a corto plazo iniciando sesión en la AWS CLI con las credenciales de inicio de sesión de la consola. Se recomienda utilizar usuarios root, usuarios de IAM o estar federados con IAM para acceder a la AWS cuenta. Para obtener instrucciones, consulte [Uso de proveedores de credenciales en](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials-temporary.html). AWS SDK for Java 2.x ### 2. Configuración del acceso de inicio de sesión único para el SDK Tras completar el paso 2 de la [sección de acceso mediante programación](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html#idcGettingStarted) para que el SDK pueda utilizar la autenticación del Centro de identidades de IAM, el sistema debe contener los siguientes elementos. + El AWS CLI, que se utiliza para iniciar una [sesión en el portal de AWS acceso](#setup-login-sso) antes de ejecutar la aplicación. + Un archivo `~/.aws/config` que contiene un perfil [predeterminado](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile). El SDK para Java utiliza la configuración de proveedor de token de SSO del perfil para adquirir las credenciales antes de enviar las solicitudes a AWS. El valor `sso_role_name`, que es un rol de IAM conectado a un conjunto de permisos del Centro de identidades de IAM, debería permitir el acceso a los Servicios de AWS utilizados en la aplicación. El siguiente archivo `config` de ejemplo muestra la configuración de un perfil predeterminado con el proveedor de token de SSO. La configuración `sso_session` del perfil hace referencia a la sección `sso-session` nombrada. La sección `sso-session` contiene la configuración para iniciar una sesión en el portal de acceso a AWS. ``` [default] sso_session = my-sso sso_account_id = 111122223333 sso_role_name = SampleRole region = us-east-1 output = json [sso-session my-sso] sso_region = us-east-1 sso_start_url = https://provided-domain.awsapps.com/start sso_registration_scopes = sso:account:access ``` Para obtener más información sobre los ajustes utilizados en la configuración del proveedor de token de SSO, consulte Configuración del proveedor de [token de SSO en la Guía](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#sso-token-config) de referencia de herramientas AWS SDKs y herramientas. Si tu entorno de desarrollo no está configurado para el acceso mediante programación como se ha mostrado anteriormente, sigue el [paso 2 de la SDKs guía de referencia](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html#idcGettingStarted). ### 3. Inicie sesión con el AWS CLI Antes de ejecutar una aplicación que acceda Servicios de AWS, necesita una sesión activa en el portal de AWS acceso para que el SDK utilice la autenticación del IAM Identity Center para resolver las credenciales. Ejecute el siguiente comando AWS CLI para iniciar sesión en el portal de AWS acceso. ``` aws sso login ``` Como tiene una configuración de perfil predeterminada, no necesita llamar al comando con una opción `--profile`. Si la configuración del proveedor de token de SSO utiliza un perfil con nombre, el comando es `aws sso login --profile named-profile`. Para comprobar si ya tiene una sesión activa, ejecute el siguiente comando de la AWS CLI . ``` aws sts get-caller-identity ``` La respuesta a este comando debe indicar la cuenta y el conjunto de permisos del Centro de identidades de IAM configurados en el archivo compartido `config`. **nota** Si ya tiene una sesión activa en el portal de AWS acceso y la ejecuta`aws sso login`, no tendrá que proporcionar credenciales. Sin embargo, verá un cuadro de diálogo en el que se solicita permiso para que `botocore` acceda a su información. `botocore` es la base de la AWS CLI . Seleccione **Permitir** para autorizar el acceso a su información para el AWS CLI SDK for Java. ## Opciones de autenticación adicionales Para obtener más opciones de autenticación para el SDK, como el uso de perfiles y variables de entorno, consulte el capítulo de [configuración](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) de la Guía de referencia de herramientas AWS SDKs y herramientas. # Creación de una aplicación sencilla mediante el AWS SDK for Java 2.x En este tutorial, se muestra cómo usar [Apache Maven](https://maven.apache.org/) para definir las dependencias del SDK para Java 2.x y, a continuación, escribir el código al que se conecta Amazon S3 para cargar un archivo. Para completar el tutorial, siga estos pasos: + [Paso 1: Configuración para este tutorial](#get-started-setup) + [Paso 2: Crear el proyecto](#get-started-projectsetup) + [Paso 3: Escribir el código](#get-started-code) + [Paso 4: Compilar y ejecutar la aplicación](#get-started-run) ## Paso 1: Configuración para este tutorial Antes de empezar este tutorial, necesitará: + Permiso de acceso Amazon S3 + Un entorno de desarrollo de Java que está configurado para acceder Servicios de AWS mediante un inicio de sesión único al AWS IAM Identity Center Use las instrucciones de [Descripción general de la configuración](setup.md#setup-overview) para configurar para este tutorial. Una vez que haya [configurado su entorno de desarrollo con acceso de inicio de sesión único para el SDK de Java y haya tenido una sesión activa en](get-started-auth.md#setup-credentials) [el portal de AWS acceso](get-started-auth.md#setup-login-sso), continúe con el paso 2 de este tutorial. ## Paso 2: Crear el proyecto Para crear el proyecto de este tutorial, ejecute un comando de Maven que le pida información sobre cómo configurar el proyecto. Una vez introducidas y confirmadas todas las entradas, Maven termina de construir el proyecto creando un archivo `pom.xml` y archivos stub de Java. 1. Abra una ventana de terminal o línea de comandos y acceda a un directorio de su elección, como su carpeta `Desktop` o `Home`. 1. Introduzca el siguiente comando en el terminal y pulse `Enter`. ``` mvn archetype:generate \ -DarchetypeGroupId=software.amazon.awssdk \ -DarchetypeArtifactId=archetype-app-quickstart \ -DarchetypeVersion=2.27.21 ``` 1. Introduzca el valor que aparece en la segunda columna para cada pregunta. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sdk-for-java/latest/developer-guide/get-started-tutorial.html) 1. Después de introducir el último valor, Maven muestra una lista de sus elecciones. Confirme introduciendo *`Y`* o vuelva a introducir los valores respondiendo con *`N`* Maven crea la carpeta del proyecto llamada `getstarted` basándose en el valor `artifactId` que haya introducido. En la carpeta `getstarted`, busque un archivo `README.md` que pueda revisar, un archivo `pom.xml` y un directorio `src`. Maven crea el árbol de directorios siguiente. ``` getstarted ├── README.md ├── pom.xml └── src ├── main │   ├── java │   │   └── org │   │   └── example │   │   ├── App.java │   │   ├── DependencyFactory.java │   │   └── Handler.java │   └── resources │   └── simplelogger.properties └── test └── java └── org └── example └── HandlerTest.java 10 directories, 7 files ``` A continuación se muestra el contenido del archivo de proyecto `pom.xml`. ### `pom.xml` La sección `dependencyManagement` contiene una dependencia con el AWS SDK for Java 2.x y la sección `dependencies` una dependencia para Amazon S3. El proyecto usa Java 1.8 debido al valor `1.8` de las `maven.compiler.target` propiedades `maven.compiler.source`. ``` 4.0.0 org.example getstarted 1.0-SNAPSHOT jar UTF-8 1.8 1.8 3.2.1 3.6.1 1.6.0 2.27.21 <-------- SDK version picked up from archetype version. 1.7.28 5.8.1 software.amazon.awssdk bom ${aws.java.sdk.version} pom import software.amazon.awssdk s3 <-------- S3 dependency software.amazon.awssdk netty-nio-client software.amazon.awssdk apache-client software.amazon.awssdk sso <-------- Required for identity center authentication. software.amazon.awssdk ssooidc <-------- Required for identity center authentication. software.amazon.awssdk apache-client <-------- HTTP client specified. commons-logging commons-logging org.slf4j slf4j-api ${slf4j.version} org.slf4j slf4j-simple ${slf4j.version} org.slf4j jcl-over-slf4j ${slf4j.version} org.junit.jupiter junit-jupiter ${junit5.version} test org.apache.maven.plugins maven-compiler-plugin ${maven.compiler.plugin.version} ``` ## Paso 3: Escribir el código En el código siguiente se muestra la clase `App` creada por Maven. El método `main` es el punto de entrada a la aplicación, que crea una instancia de la `Handler` clase y, a continuación, llama a su método `sendRequest`. ### Clase `App` ``` package org.example; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class App { private static final Logger logger = LoggerFactory.getLogger(App.class); public static void main(String... args) { logger.info("Application starts"); Handler handler = new Handler(); handler.sendRequest(); logger.info("Application ends"); } } ``` La clase `DependencyFactory` creada por Maven contiene el método de fábrica `s3Client` que crea y devuelve una instancia [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html). La instancia `S3Client` usa una instancia del cliente HTTP basado en Apache. Esto se debe a que especificó `apache-client` cuando Maven preguntó qué cliente HTTP usar. La `DependencyFactory` muestra en el siguiente código. ### Clase `DependencyFactory` ``` package org.example; import software.amazon.awssdk.http.apache.ApacheHttpClient; import software.amazon.awssdk.services.s3.S3Client; /** * The module containing all dependencies required by the {@link Handler}. */ public class DependencyFactory { private DependencyFactory() {} /** * @return an instance of S3Client */ public static S3Client s3Client() { return S3Client.builder() .httpClientBuilder(ApacheHttpClient.builder()) .build(); } } ``` La clase `Handler` contiene la lógica principal del programa. Cuando se crea una instancia de `Handler` en la clase `App`, `DependencyFactory` proporciona el cliente de servicios `S3Client`. El código utiliza la instancia de `S3Client` para llamar al servicio Amazon S3. Maven genera la siguiente clase `Handler` con un comentario `TODO`. El siguiente paso del tutorial reemplaza el *`TODO`* por código. ### Clase `Handler`, generada por Maven ``` package org.example; import software.amazon.awssdk.services.s3.S3Client; public class Handler { private final S3Client s3Client; public Handler() { s3Client = DependencyFactory.s3Client(); } public void sendRequest() { // TODO: invoking the api calls using s3Client. } } ``` Para completar la lógica, reemplace todo el contenido de la clase `Handler` por el código siguiente. El método `sendRequest` se rellena y se añaden las importaciones necesarias. ### Clase `Handler`, implementada En primer lugar, el código crea un nuevo bucket de S3 con la última parte del nombre generado utilizando `System.currentTimeMillis()` para que el nombre del bucket sea único. Tras crear el bucket en el método `createBucket()`, el programa carga un objeto mediante el método [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html#putObject(software.amazon.awssdk.services.s3.model.PutObjectRequest,software.amazon.awssdk.core.sync.RequestBody)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html#putObject(software.amazon.awssdk.services.s3.model.PutObjectRequest,software.amazon.awssdk.core.sync.RequestBody)) de `S3Client`. El contenido del objeto es una cadena simple creada con el método `RequestBody.fromString`. Por último, el programa elimina el objeto seguido del bucket del método `cleanUp`. ``` package org.example; import software.amazon.awssdk.core.sync.RequestBody; import software.amazon.awssdk.services.s3.S3Client; import software.amazon.awssdk.services.s3.model.CreateBucketRequest; import software.amazon.awssdk.services.s3.model.DeleteBucketRequest; import software.amazon.awssdk.services.s3.model.DeleteObjectRequest; import software.amazon.awssdk.services.s3.model.HeadBucketRequest; import software.amazon.awssdk.services.s3.model.PutObjectRequest; import software.amazon.awssdk.services.s3.model.S3Exception; public class Handler { private final S3Client s3Client; public Handler() { s3Client = DependencyFactory.s3Client(); } public void sendRequest() { String bucket = "bucket" + System.currentTimeMillis(); String key = "key"; createBucket(s3Client, bucket); System.out.println("Uploading object..."); s3Client.putObject(PutObjectRequest.builder().bucket(bucket).key(key) .build(), RequestBody.fromString("Testing with the {sdk-java}")); System.out.println("Upload complete"); System.out.printf("%n"); cleanUp(s3Client, bucket, key); System.out.println("Closing the connection to {S3}"); s3Client.close(); System.out.println("Connection closed"); System.out.println("Exiting..."); } public static void createBucket(S3Client s3Client, String bucketName) { try { s3Client.createBucket(CreateBucketRequest .builder() .bucket(bucketName) .build()); System.out.println("Creating bucket: " + bucketName); s3Client.waiter().waitUntilBucketExists(HeadBucketRequest.builder() .bucket(bucketName) .build()); System.out.println(bucketName + " is ready."); System.out.printf("%n"); } catch (S3Exception e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } } public static void cleanUp(S3Client s3Client, String bucketName, String keyName) { System.out.println("Cleaning up..."); try { System.out.println("Deleting object: " + keyName); DeleteObjectRequest deleteObjectRequest = DeleteObjectRequest.builder().bucket(bucketName).key(keyName).build(); s3Client.deleteObject(deleteObjectRequest); System.out.println(keyName + " has been deleted."); System.out.println("Deleting bucket: " + bucketName); DeleteBucketRequest deleteBucketRequest = DeleteBucketRequest.builder().bucket(bucketName).build(); s3Client.deleteBucket(deleteBucketRequest); System.out.println(bucketName + " has been deleted."); System.out.printf("%n"); } catch (S3Exception e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } System.out.println("Cleanup complete"); System.out.printf("%n"); } } ``` ## Paso 4: Compilar y ejecutar la aplicación Una vez creado el proyecto y que contenga la clase `Handler` completa, compile y ejecute la aplicación. 1. Asegúrese de que tenga una sesión activa del Centro de identidades de IAM. Para ello, ejecute el AWS Command Line Interface comando `aws sts get-caller-identity` y compruebe la respuesta. Si no tiene una sesión activa, consulte [esta sección](get-started-auth.md#setup-login-sso) para obtener instrucciones. 1. Abra una ventana de terminal o símbolo del sistema y desplácese hasta el directorio del proyecto `getstarted`. 1. Para compilar su proyecto, utilice el comando siguiente: ``` mvn clean package ``` 1. Para ejecutar la aplicación, utilice el comando siguiente. ``` mvn exec:java -Dexec.mainClass="org.example.App" ``` Para ver el bucket y el objeto nuevos creados por el programa, siga los pasos descritos a continuación. 1. En `Handler.java`, comente la línea `cleanUp(s3Client, bucket, key)` del método `sendRequest` y guarde el archivo. 1. Recompile el proyecto ejecutando `mvn clean package`. 1. Vuelva a ejecutar `mvn exec:java -Dexec.mainClass="org.example.App"` para cargar el objeto de texto una vez más. 1. Inicie sesión en [la consola de S3](https://console.aws.amazon.com/s3/) para ver el nuevo objeto en el bucket recién creado. Después de ver el archivo, elimine el objeto y, a continuación, elimine el bucket. ### Success Si su proyecto de Maven se creó y ejecutó sin errores, ¡enhorabuena\$1 Ha creado correctamente su primera aplicación Java mediante SDK para Java 2.x. ### Limpieza Para limpiar los recursos que ha creado en este tutorial, haga lo siguiente: + Si aún no lo ha hecho, en [la consola de S3](https://console.aws.amazon.com/s3/), elimine todos los objetos y buckets creados al ejecutar la aplicación. + Elimine la carpeta del proyecto (`getstarted`). ## Siguientes pasos Ahora que ya ha aprendido lo básico, puede aprender lo siguiente: + [Trabajando con Amazon S3](examples-s3.md) + [Trabajar con otros Amazon Web Services[DynamoDB[Amazon EC2](examples-ec2.md)](examples-dynamodb.md)](work-with-services.md), como y [varios servicios de bases de datos](examples-databases.md) + [Usar el SDK](using.md) + [Seguridad para AWS SDK para Java](security.md) **