翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# AWS SDK for Java 2.x の開始方法
このトピックのセクションでは、AWS のサービス に接続する Java アプリケーションの構築を開始するための重要なステップについて説明します。このセクションでは、Java を使用した開発環境のセットアップ、Maven や Gradle などのツールの構築、AWS への安全な認証の設定について説明し、動作する最初のアプリケーションを作成する実践的なチュートリアルを提供します。この初心者向けのトピックは、Java を使用した AWS のためのエントリポイントとして機能し、より高度な機能を検討する前に必要な土台となります。
**Contents**
+ [AWS SDK for Java 2.x の設定](setup.md)
+ [設定の概要](setup.md#setup-overview)
+ [Java とビルドツールをインストールして を操作する AWS SDK for Java 2.x](setup-java-buildtool.md)
+ [を使用する Apache Maven プロジェクトを設定する AWS SDK for Java 2.x](setup-project-maven.md)
+ [前提条件](setup-project-maven.md#prerequisitesmaven)
+ [Maven プロジェクトを作成する](setup-project-maven.md#create-maven-project)
+ [Maven 用の Java コンパイラを設定する](setup-project-maven.md#configure-maven-compiler)
+ [SDK を依存関係として宣言する](setup-project-maven.md#sdk-as-dependency)
+ [SDK モジュールの依存関係を設定する](setup-project-maven.md#modules-dependencies)
+ [SDK 全体のプロジェクトへのビルド](setup-project-maven.md#build-the-entire-sdk-into-your-project)
+ [プロジェクトを構築する](setup-project-maven.md#build-project)
+ [を使用する Gradle プロジェクトを設定する AWS SDK for Java 2.x](setup-project-gradle.md)
+ [を使用する GraalVM ネイティブイメージプロジェクトを設定する AWS SDK for Java 2.x](setup-project-graalvm.md)
+ [前提条件](setup-project-graalvm.md#setup-graalvmnativeimage-prereq)
+ [アーキタイプを使用してプロジェクトを作成する](setup-project-graalvm.md#setup-graalvmnativeimage-project)
+ [ネイティブイメージを構築する](setup-project-graalvm.md#build-graalvmnativeimage-project)
+ [AWS を使用した での認証 AWS SDK for Java 2.x](get-started-auth.md)
+ [認証の設定](get-started-auth.md#setup-auth)
+ [1. 短期認証情報を使用したローカル開発](get-started-auth.md#setup-login)
+ [2. SDK のシングルサインオンアクセスの設定](get-started-auth.md#setup-credentials)
+ [3. を使用してサインインする AWS CLI](get-started-auth.md#setup-login-sso)
+ [追加認証オプション](get-started-auth.md#setup-additional)
+ [を使用したシンプルなアプリケーションの作成 AWS SDK for Java 2.x](get-started-tutorial.md)
+ [ステップ 1: このチュートリアルのために設定する](get-started-tutorial.md#get-started-setup)
+ [ステップ 2: プロジェクトを作成する](get-started-tutorial.md#get-started-projectsetup)
+ [ステップ 3: コードを記述する](get-started-tutorial.md#get-started-code)
+ [ステップ 4: アプリケーションを構築して実行する](get-started-tutorial.md#get-started-run)
+ [Success](get-started-tutorial.md#get-started-success)
+ [クリーンアップ](get-started-tutorial.md#cleanup)
+ [次の手順](get-started-tutorial.md#get-started-next)
# AWS SDK for Java 2.x の設定
このセクションでは、AWS SDK for Java 2.x を使用する開発環境とプロジェクトについて説明します。
## 設定の概要
AWS SDK for Java で AWS のサービス を使用してアクセスするアプリケーションを正常に開発するには、次の条件が必要です。
+ Java SDK は、ユーザーに代わって[リクエストを認証](get-started-auth.md#setup-auth)するための認証情報にアクセスできる必要があります。
+ SDK 用に設定された [IAM ロールのアクセス許可](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html)により、アプリケーションが必要とする AWS のサービス へのアクセスが許可されている必要があります。**PowerUserAccess** AWS 管理ポリシーに関連するアクセス許可は、ほとんどの開発ニーズに十分対応できます。
+ 以下の要素を備えた開発環境:
+ [共有設定ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)は、次のいずれかの方法で設定できます。
+ `config` ファイルには、SDK が AWS 認証情報を取得できるようにするための [IAM Identity Center シングルサインオン設定](get-started-auth.md#setup-credentials)が含まれています。
+ `credentials` ファイルには一時的な認証情報が含まれています。
+ [Java 8 以降のインストール](setup-java-buildtool.md)。
+ [Maven](https://maven.apache.org/download.cgi) や [Gradle](https://gradle.org/install/) などの[構築オートメーションツール](setup-java-buildtool.md)。
+ コードを使用するテキストエディター。
+ (オプションだが推奨) [IntelliJ IDEA](https://www.jetbrains.com/idea/download/#section=windows)、[Eclipse](https://www.eclipse.org/ide/)、[NetBeans](https://netbeans.apache.org/front/main/download/index.html) などの IDE (統合開発環境)。
IntelliJ IDEA を使用する場合は、IDE に AWS のサービス を直接統合する [AWS Toolkit for IntelliJ IDEA](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html) を追加して、開発を合理化することもできます。
+ アプリケーションを実行する準備ができたときの、AWS アクティブアクセスポータルセッションです。AWS Command Line Interface を使用して IAM Identity Center の AWS アクセスポータルへの[サインインプロセスを開始](get-started-auth.md#setup-login-sso)します。
**重要**
このセットアップセクションの手順は、ユーザーまたは組織が IAM Identity Center を使用していることを前提としています。組織が IAM アイデンティティセンターとは独立して機能する外部 ID プロバイダーを使用している場合は、SDK for Java で使用するための一時的な認証情報を取得する方法をご確認ください。[以下の手順](credentials-temporary.md#credentials-temporary-from-portal)に従って、`~/.aws/credentials` ファイルに一時的な認証情報を追加します。
ID プロバイダーが一時的な認証情報を `~/.aws/credentials` ファイルに自動的に追加する場合は、SDK または AWS CLI にプロファイル名を指定する必要がないように、プロファイル名が `[default]` であることを確認してください。
# Java とビルドツールをインストールして を操作する AWS SDK for Java 2.x
SDK for Java 2.x を使用するには、以下の Java 開発環境要件が必要です。
+ Java 8 以降。は、[Oracle Java SE Development Kit ](https://www.oracle.com/java/technologies/downloads/)と、、Red Hat OpenJDK[Amazon Corretto](https://aws.amazon.com/corretto/)、[Adoptium](https://adoptium.net/) などの Open Java Development Kit (OpenJDK) のディストリビューションで AWS SDK for Java 動作します。 [ OpenJDK](https://developers.redhat.com/products/openjdk/overview)
+ Apache Maven、Apache Ant と Ivy、Gradle、IntelliJ などの Maven 互換のビルドツール。
+ Maven をインストールして使用する方法については、[https://maven.apache.org/](https://maven.apache.org/) を参照してください。
+ Apache Ivy をインストールして使用する方法については、[https://ant.apache.org/ivy/](https://ant.apache.org/ivy/) を参照してください。
+ Gradle をインストールして使用する方法については、[https://gradle.org/](https://gradle.org/) を参照してください。
+ IntelliJ IDEA をインストールして使用する方法については、[https://www.jetbrains.com/idea/](https://www.jetbrains.com/idea/) を参照してください。
# を使用する Apache Maven プロジェクトを設定する AWS SDK for Java 2.x
[Apache Maven](https://maven.apache.org/) を使用して、 AWS SDK for Java 2.x プロジェクトの設定および構築、[SDK 自体の構築](https://github.com/aws/aws-sdk-java-v2/tree/master#building-from-source)を行うことができます。
## 前提条件
Maven で SDK for Java 2.x を使用するには、次が必要です。
+ Java *8.0 以降*。最新の Java SE Development Kit ソフトウェアは [http://www.oracle.com/technetwork/java/javase/downloads/](https://www.oracle.com/java/technologies/downloads/) からダウンロードできます。SDK for Java 2.x は Amazon Corretto、[OpenJDK](https://openjdk.org/) および Open Java Development Kit (OpenJDK) のディストリビューションとも連携します。最新の OpenJDK バージョンは [https://openjdk.java.net/install/index.html](https://openjdk.org/install/index.html) からダウンロードしてください。ページから最新の Amazon Corretto 8 または Amazon Corretto 11 バージョンをダウンロードします。 [Corretto](https://aws.amazon.com/corretto/)
+ *Apache Maven*。Maven をインストールする必要がある場合は、[http://maven.apache.org/](https://maven.apache.org/) にアクセスしてダウンロードおよびインストールします。
## Maven プロジェクトを作成する
コマンドラインから Maven プロジェクトを作成するには、ターミナルまたはコマンドプロンプトウィンドウ ```` で、次のコマンドを実行します。
```
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
```
**注記**
*com.example.myapp* をアプリケーションの完全パッケージ名前空間に置き換えます。また、*myapp* をプロジェクト名に置き換えます。これがプロジェクトのディレクトリの名前になります。
アーキタイプの最新バージョンを使用するには、*2.X.X* を [Maven 中央の最新バージョン](https://central.sonatype.com/artifact/software.amazon.awssdk/archetype-lambda)に置き換えてください。
このコマンドにより、アーキタイプテンプレートツールキットを使用して Maven プロジェクトが作成されます。アーキタイプは、 AWS Lambda 関数ハンドラープロジェクト のスキャフォールドを生成します。このプロジェクトのアーキタイプは、Java SE 8 でコンパイルするように事前設定されており、`-DarchetypeVersion` で指定された Java 2.x 用 SDK のバージョンへの依存関係が含まれています。
Maven プロジェクトの作成と設定の詳細については、「[Maven 入門ガイド](https://maven.apache.org/guides/getting-started/)」を参照してください。
## Maven 用の Java コンパイラを設定する
前述のようにプロジェクトアーキタイプを使用して AWS Lambda プロジェクトを作成した場合、Java コンパイラの設定はすでに完了しています。
この設定が存在することを確認するには、まず、前のコマンドを実行したときに作成したプロジェクトフォルダ (`myapp` など) から `pom.xml` ファイルを開きます。11 行目と 12 行目を見て、この Maven プロジェクトの Java コンパイラのバージョン設定を確認します。また、71～75 行目を見て、必要な Maven コンパイラプラグインが含まれていることを確認します。
```
1.8
1.8
org.apache.maven.plugins
maven-compiler-plugin
${maven.compiler.plugin.version}
```
別のアーキタイプで、または別の方法を使用してプロジェクトを作成する場合は、Maven コンパイラプラグインがビルドの一部となっており、そのソースプロパティとターゲットプロパティの両方が `pom.xml` ファイルで **1.8** に設定されているようにする必要があります。
これらの必須の設定を指定する 1 つの方法として、前述のスニペットを参照してください。
または、次のように、プラグイン宣言を使用してインラインでコンパイラ設定を指定することもできます。
```
org.apache.maven.plugins
maven-compiler-plugin
1.8
1.8
```
## SDK を依存関係として宣言する
プロジェクト AWS SDK for Java で を使用するには、プロジェクトの `pom.xml` ファイルで依存関係として宣言する必要があります。
前述のようにプロジェクトアーキタイプを使用してプロジェクトを作成した場合、SDK の最新バージョンはすでにプロジェクトの依存関係として設定されています。
アーキタイプによって `software.amazon.awssdk` グループ ID の BOM (部品表) アーティファクト依存関係が生成されます。BOM を使用すると、同じグループ ID を共有する個々のアーティファクトの依存関係に Maven バージョンを指定する必要がありません。
別の方法で Maven プロジェクトを作成した場合は、`pom.xml` ファイルに次の内容が含まれていることを確認して、プロジェクトの最新バージョンの SDK を設定します。
```
2.X.X
software.amazon.awssdk
bom
${aws.java.sdk.version}
pom
import
```
**注記**
`pom.xml` ファイル内の *2.X.X* を[最新バージョンの AWS SDK for Java 2.x](https://central.sonatype.com/artifact/software.amazon.awssdk/bom) に置き換えます。
## SDK モジュールの依存関係を設定する
SDK を設定したら、プロジェクトで使用する 1 つ以上の AWS SDK for Java モジュールの依存関係を追加できます。
各コンポーネントのバージョン番号を指定できますが、部品表アーティファクトを使用する `dependencyManagement` セクションで SDK バージョンをすでに宣言しているため、その必要はありません。特定のモジュールの異なるバージョンをロードするには、その依存関係のバージョン番号を指定します。
前述のように、プロジェクトのアーキタイプを使用してプロジェクトを作成した場合、プロジェクトはすでに複数の依存関係で設定されています。これらには、次のような AWS Lambda 関数ハンドラーと Amazon S3 の依存関係が含まれます。
```
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}
```
**注記**
上の `pom.xml` 例では、依存関係は異なる `groupId` からのものです。`s3` 依存関係は `software.amazon.awssdk` からのもので、`aws-lambda-java-core` 依存関係は `com.amazonaws` からのものです。BOM 依存関係管理設定は `software.amazon.awssdk` のアーティファクトに影響するため、`aws-lambda-java-core` アーティファクトにはバージョンが必要です。
Java 2.x 用の SDK を使用して *Lambda 関数ハンドラー*を開発する場合は、`aws-lambda-java-core` が正しい依存関係です。ただし `listFunctions`、`deleteFunction`、`invokeFunction` および `createFunction` などのオペレーションを使用して Lambda リソースを管理する必要があるアプリケーションには、次の依存関係が必要です。
```
software.amazon.awssdk
lambda
```
**注記**
`s3` 依存関係には、`netty-nio-client` および `apache-client` 推移的な依存関係は含まれません。アーキタイプには、これらの HTTP クライアントの代わりに `url-connection-client` 依存関係が含まれるため、[AWS Lambda 関数の起動レイテンシーを短縮](lambda-optimize-starttime.md#lambda-quick-url)できます。
プロジェクトに必要な AWS のサービス および 機能のモジュールをプロジェクトに追加します。 AWS SDK for Java BOM によって管理されるモジュール (依存関係) は [Maven の中央リポジトリ](https://central.sonatype.com/artifact/software.amazon.awssdk/bom)に一覧表示されます。
**注記**
コード例から `pom.xml` ファイルを参照して、プロジェクトに必要な依存関係を特定できます。たとえば、DynamoDB サービスの依存関係に関心がある場合は、GitHub の「[AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2)」にある「[This example](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/dynamodb/pom.xml)」を参照してください。([/javav2/example\$1code/dynamodb](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/dynamodb) にある `pom.xml` ファイルを確認してください。)
### SDK 全体のプロジェクトへのビルド
アプリケーションを最適化するため、SDK 全体ではなく必要なコンポーネントのみインポートすることを強くお勧めします。ただし、 全体をプロジェクト AWS SDK for Java に構築するには、次のように `pom.xml` ファイルで宣言します。
```
software.amazon.awssdk
aws-sdk-java
2.X.X
```
## プロジェクトを構築する
`pom.xml` ファイルを設定したら、Maven を使用してプロジェクトをビルドできます。
コマンドラインから Maven プロジェクトを構築するには、ターミナルウィンドウまたはコマンドプロンプトウィンドウを開き、プロジェクトディレクトリ (`myapp` など) に移動し、次のコマンドを入力するか、貼り付けて Enter キーまたは Return キーを押します。
```
mvn package
```
これにより、`target` ディレクトリに 1 つの `.jar` ファイル (JAR) が作成されます (例: `myapp/target`)。この JAR には、`pom.xml` ファイルの依存関係として指定したすべての SDK モジュールが含まれています。
# を使用する Gradle プロジェクトを設定する AWS SDK for Java 2.x
[Gradle](https://gradle.org/) を使用して、 AWS SDK for Java 2.x プロジェクトを設定および構築できます。
次の例での最初のステップは、「[Gradle's Getting Started guide](https://docs.gradle.org/current/samples/sample_building_java_applications.html)」バージョン 8.4 用からのものです。別のバージョンを使用すると、結果が多少異なる場合があります。
**Gradle で Java アプリケーションを作成する方法 (コマンドライン)**
1. プロジェクトを格納するディレクトリを作成します。この例では、`demo` がディレクトリ名です。
1. `demo` ディレクトリ内で `gradle init` コマンドを実行し、次のコマンドライン出力に示すように、赤で強調表示されている値を指定します。ここでは、ビルドスクリプト DSL 言語として「Kotlin」を選択しますが、このトピックの最後には「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. `init` タスクが完了すると、`demo` ディレクトリには次のツリー構造を含みます。次のセクションでは、メインのビルドファイル、`build.gradle.kts` (赤でハイライト) を詳しく見ていきます。
```
├── 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
```
`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 {
// 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. スキャフォールドされた Gradle ビルドファイルを AWS プロジェクトの基礎として使用します。
1. Gradle プロジェクトの SDK 依存関係を管理するには、 の Maven 部品表 (BOM) AWS SDK for Java 2.x を `build.gradle.kts`ファイルの `dependencies`セクションに追加します。
```
...
dependencies {
implementation(platform("software.amazon.awssdk:bom:2.27.21"))
// With the bom declared, you specify individual SDK dependencies without a version.
...
}
...
```
**注記**
この例では、 *2.27.21*を SDK for Java 2.x の最新バージョンに置き換えます。[Maven 中央リポジトリ](https://central.sonatype.com/artifact/software.amazon.awssdk/bom/versions)で入手可能な最新バージョンを確認してください。
1. アプリケーションが必要とする SDK モジュールを `dependencies` セクションで指定してください。例として、以下では Amazon Simple Storage Service への依存関係を追加します。
```
...
dependencies {
implementation(platform("software.amazon.awssdk:bom:2.27.21"))
implementation("software.amazon.awssdk:s3")
...
}
...
```
Gradle は BOM の情報を使用して、正しいバージョンの宣言された依存関係を自動的に解決します。
以下の例は、Kotlin と Groovy DSL の両方における完全な Gradle ビルドファイルを示しています。ビルドファイルには、Amazon S3、認証、ログ記録、テストの依存関係が含まれています。Java のソースおよびターゲットバージョンはバージョン 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()
}
```
------
次のステップについては、Gradle ウェブサイトの「入門ガイド」で、[Gradle アプリケーションをビルドして実行する](https://docs.gradle.org/current/samples/sample_building_java_applications.html#run_the_application)方法を確認してください。
# を使用する GraalVM ネイティブイメージプロジェクトを設定する AWS SDK for Java 2.x
バージョン 2.16.1 以降では、 AWS SDK for Java 2.x は GraalVM ネイティブイメージアプリケーションのout-of-the-boxサポートを提供します。`archetype-app-quickstart` Maven アーキタイプを使用して、ネイティブイメージサポートが組み込まれたプロジェクトを設定します。
## 前提条件
+ [AWS SDK for Java 「2.x のセットアップ」のステップを完了します](setup.md)。
+ [GraalVM Native Image](https://www.graalvm.org/reference-manual/native-image/#install-native-image) をインストールします。
## アーキタイプを使用してプロジェクトを作成する
ネイティブイメージサポートが組み込まれた Maven プロジェクトを作成するには、ターミナルまたはコマンドプロンプトウィンドウで、次のコマンドを使用します。
**注記**
アプリケーションのフルパッケージ名前空間を `com.example.mynativeimageapp` に置き換えます。また、`mynativeimageapp` をプロジェクト名に置き換えます。これがプロジェクトのディレクトリの名前になります。
```
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
```
このコマンドは、 AWS SDK for Java、 Amazon S3、および HTTP クライアントの依存関係で設定された Maven `ApacheHttpClient` プロジェクトを作成します。また、[GraalVM Native Image Maven プラグイン](https://graalvm.github.io/native-build-tools/latest/index.html)への依存関係も含まれているため、Maven を使用してネイティブイメージを構築できます。
別の の依存関係を含めるには Amazon Web Services、 `-Dservice`パラメータの値をそのサービスのアーティファクト ID に設定します。例には、`dynamodb`、`comprehend`、`pinpoint` が含まれます。アーティファクト ID の詳細なリストについては、[Maven Central の software.amazon.awssdk](https://mvnrepository.com/artifact/software.amazon.awssdk/bom/latest) のマネージド依存関係のリストを参照してください。
非同期 HTTP クライアントを使用するには、`-DhttpClient` パラメータを `netty-nio-client` に設定します。同期 HTTP クライアントとして `apache-client` の代わりに `UrlConnectionHttpClient` を使用するには、`-DhttpClient` パラメータを `url-connection-client` に設定します。
## ネイティブイメージを構築する
プロジェクトを作成したら、プロジェクトディレクトリから次のコマンドを実行します (例: `mynativeimageapp`:)。
```
mvn package -P native-image
```
これにより、`target` ディレクトリにネイティブイメージアプリケーションが作成されます (例: `target/mynativeimageapp`)。
# AWS を使用した での認証 AWS SDK for Java 2.x
AWS サービスの開発 AWS 時に が で AWS SDK for Java 2.x 認証する方法を確立する必要があります。SDK は、認証情報の検出、署名の作成、認証情報の更新を完全にバックグラウンドで管理するため、ユーザーはアプリケーションロジックに集中できます。
## 認証の設定
AWS SDKs[およびツールリファレンスガイド」の「認証とアクセス](https://docs.aws.amazon.com/sdkref/latest/guide/access.html)」トピックでは、さまざまな認証アプローチについて説明します。
ローカル開発では、コンソールのログイン認証情報を使用して AWS CLI にログインし、短期認証情報を使用することをお勧めします。 AWS アカウントアクセスにルート、IAM ユーザー、または IAM とのフェデレーションを使用する場合に推奨されます。[を使用してインタラクティブ開発作業の認証情報にアクセスする AWS SDK for Java 2.x](credentials-temporary.md) の指示に従います。
AWS SDKs およびツールリファレンスガイドの手順に従って、SDK がリクエストに署名できるようにシステムを設定する必要があります。
### 1. 短期認証情報を使用したローカル開発
ローカル開発では、コンソールのログイン認証情報を使用して AWS CLI にログインし、短期認証情報を使用することをお勧めします。 AWS アカウントアクセスにルート、IAM ユーザー、または IAM とのフェデレーションを使用する場合に推奨されます。
手順については、 [の「認証情報プロバイダーの使用 AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials-temporary.html)」を参照してください。
### 2. SDK のシングルサインオンアクセスの設定
SDK が IAM Identity Center 認証を使用するように[「プログラムによるアクセス」セクション](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html#idcGettingStarted)のステップ 2 を完了したら、システムに次の要素が含まれているはずです。
+ アプリケーションを実行する前に [AWS アクセスポータルセッション](#setup-login-sso)を開始 AWS CLIするために使用する 。
+ [デフォルトプロファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile)を含む `~/.aws/config` ファイル。SDK for Java は、リクエストを AWSに送信する前に、プロファイルの SSO トークンプロバイダー設定を使用して認証情報を取得します。IAM Identity Center 許可セットに接続された IAM ロールである `sso_role_name` 値により、アプリケーションで使用されている AWS のサービス にアクセスできます。
次のサンプル `config` ファイルは、SSO トークンプロバイダー設定で設定されたデフォルトプロファイルを示しています。プロファイルの `sso_session` 設定は、指定された `sso-session` セクションを参照します。`sso-session` セクションには、 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
```
SSO トークンプロバイダー設定で使用される設定の詳細については、「 AWS SDKs and Tools リファレンスガイド」の「[SSO token provider configuration](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#sso-token-config)」を参照してください。
開発環境が前述のようにプログラムによるアクセス用に設定されていない場合は、[SDK リファレンスガイドのステップ 2](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html#idcGettingStarted) に従ってください。
### 3. を使用してサインインする AWS CLI
にアクセスするアプリケーションを実行する前に AWS のサービス、SDK が IAM Identity Center 認証を使用して認証情報を解決するには、アクティブな AWS アクセスポータルセッションが必要です。で次のコマンドを実行して AWS CLI 、 AWS アクセスポータルにサインインします。
```
aws sso login
```
デフォルトのプロファイルを設定している場合は、`--profile` オプションを指定してコマンドを呼び出す必要はありません。SSO トークンプロバイダー設定で名前付きプロファイルを使用している場合、コマンドは `aws sso login --profile named-profile` です。
既にアクティブなセッションがあるかどうかをテストするには、次の AWS CLI コマンドを実行します。
```
aws sts get-caller-identity
```
このコマンドへの応答により、共有 `config` ファイルに設定されている IAM Identity Center アカウントとアクセス許可のセットが報告されます。
**注記**
既にアクティブな AWS アクセスポータルセッションがあり、 を実行している場合は`aws sso login`、認証情報を指定する必要はありません。
ただし、`botocore` に情報へのアクセス許可を求めるダイアログが表示されます。`botocore` は AWS CLI の基盤です。
AWS CLI および SDK for ****Java の情報へのアクセスを許可する を選択します。
## 追加認証オプション
プロファイルや環境変数の使用など、SDK の認証に関するその他のオプションについては、 AWS SDKsおよびツールリファレンスガイド[の設定](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html)の章を参照してください。
# を使用したシンプルなアプリケーションの作成 AWS SDK for Java 2.x
このチュートリアルでは、[Apache Maven](https://maven.apache.org/) を使用して SDK for Java 2.x の依存関係を定義し、 Amazon S3 に接続してファイルをアップロードするコードを記述する方法を説明します。
このチュートリアルを完了するには、次の手順に従ってください。
+ [ステップ 1: このチュートリアルのために設定する](#get-started-setup)
+ [ステップ 2: プロジェクトを作成する](#get-started-projectsetup)
+ [ステップ 3: コードを記述する](#get-started-code)
+ [ステップ 4: アプリケーションを構築して実行する](#get-started-run)
## ステップ 1: このチュートリアルのために設定する
このチュートリアルを開始する前に、以下を実行する必要があります
+ アクセス許可 Amazon S3
+ へのシングルサインオン AWS のサービス を使用して にアクセスするように設定された Java 開発環境 AWS IAM アイデンティティセンター
[設定の概要](setup.md#setup-overview) の手順に従って、このチュートリアルの設定を行ってください。Java SDK の[シングルサインオンアクセスを使用して開発環境を設定し](get-started-auth.md#setup-credentials)、[アクティブな AWS アクセスポータルセッション](get-started-auth.md#setup-login-sso)を作成したら、このチュートリアルのステップ 2 に進みます。
## ステップ 2: プロジェクトを作成する
このチュートリアル用のプロジェクトを作成するには、プロジェクトの設定方法に関する入力を求める Maven コマンドを実行します。すべての入力と確認が完了すると、Maven は `pom.xml` を作成してプロジェクトの構築を終了し、スタブ Java ファイルを作成します。
1. ターミナルまたはコマンドプロンプトウィンドウを開き、`Desktop` や `Home` フォルダなど、任意のディレクトリに移動します。
1. ターミナルに以下のコマンドを入力して、`Enter` を押します。
```
mvn archetype:generate \
-DarchetypeGroupId=software.amazon.awssdk \
-DarchetypeArtifactId=archetype-app-quickstart \
-DarchetypeVersion=2.27.21
```
1. 各プロンプトの 2 列目にリストされている値を入力します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/sdk-for-java/latest/developer-guide/get-started-tutorial.html)
1. 最後の値を入力すると、Maven は選択した内容を一覧表示します。*`Y`* を入力して確認するか、*`N`* を入力して値を再入力します。
Maven は、入力した `getstarted` 値に基づいて `artifactId` という名前が付けられたプロジェクトフォルダーを作成します。`getstarted` フォルダー内で、レビューできる `README.md` ファイル、`pom.xml` ファイル、および `src` ディレクトリを検索します。
Maven は以下のディレクトリーツリーを構築します。
```
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
```
以下は、`pom.xml` プロジェクトファイルの内容を示しています。
### `pom.xml`
`dependencyManagement` セクションには AWS SDK for Java 2.x に対する依存関係が含まれており、`dependencies` セクションには Amazon S3 に対する依存関係があります。プロジェクトでは Java 1.8 が使用されています。これは、`maven.compiler.source`、`maven.compiler.target` およびプロパティに `1.8` 値があるためです。
```
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}
```
## ステップ 3: コードを記述する
次のコードは Maven によって作成された `App` クラスを示しています。`main` メソッドはアプリケーションへのエントリポイントであり、`Handler` クラスのインスタンスを作成してその `sendRequest` メソッドを呼び出します。
### `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");
}
}
```
Maven が作成する `DependencyFactory` クラスには、[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) インスタンスを構築して返す `s3Client` ファクトリメソッドが含まれています。`S3Client` インスタンスは Apache ベースの HTTP クライアントのインスタンスを使用します。これは、どの HTTP クライアントを使用するかを Maven が求めたときに `apache-client` が指定されたためです。
`DependencyFactory` は次のコードに示されています。
### `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();
}
}
```
`Handler` クラスにはプログラムのメインロジックが含まれています。`Handler` のインスタンスが `App` クラス内で作成されると、`DependencyFactory` は `S3Client` サービスクライアントを配置します。コードは、`S3Client` インスタンスを使用して Amazon S3 サービスを呼び出します。
Maven は `TODO` コメント付きの次の `Handler` クラスを生成します。チュートリアルの次のステップでは、*`TODO`* をコードに置き換えます。
### Maven によって生成された `Handler` クラス
```
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.
}
}
```
ロジックを設定するには、`Handler` クラスのすべてのコンテンツを次のコードに置き換えます。`sendRequest` メソッドが入力され、必要なインポートが追加されます。
### `Handler` クラス、実装済み
このコードはまず、バケット名を一意にするために、`System.currentTimeMillis()` を使用して生成された名前の最後の部分を使用して新しい S3 バケットを作成します。
`createBucket()` メソッドでバケットを作成すると、プログラムは `S3Client` の [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)) メソッドを使用してオブジェクトをアップロードします。オブジェクトの内容は、`RequestBody.fromString` メソッドで作成された単純な文字列です。
最後に、プログラムは、`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");
}
}
```
## ステップ 4: アプリケーションを構築して実行する
プロジェクトが作成され、完全な `Handler` クラスを含めたら、アプリケーションを構築して実行します。
1. IAM Identity Center セッションがアクティブであることを確認してください。これを行うには、 AWS Command Line Interface コマンドを実行してレスポンス`aws sts get-caller-identity`を確認します。アクティブなセッションがない場合は、[このセクション](get-started-auth.md#setup-login-sso)の手順を参照してください。
1. ターミナルまたはコマンドプロンプトウィンドウを開いて、プロジェクトディレクトリ `getstarted` に移動します。
1. プロジェクトを構築するには、以下のコマンドを使用します。
```
mvn clean package
```
1. 次のコマンドを使用して、アプリケーションを実行します。
```
mvn exec:java -Dexec.mainClass="org.example.App"
```
プログラムが作成した新しいバケットとオブジェクトを表示するには、次のステップを実行します。
1. `Handler.java` で、`sendRequest` メソッド内の `cleanUp(s3Client, bucket, key)` 行をコメントアウトし、ファイルを保存します。
1. `mvn clean package` を実行してプロジェクトを再構築します。
1. `mvn exec:java -Dexec.mainClass="org.example.App"` を再実行してテキストオブジェクトをもう一度アップロードします。
1. [S3 コンソール](https://console.aws.amazon.com/s3/)にサインインして、新しく作成されたバケット内の新しい対象を表示します。
ファイルを表示した後、オブジェクトを削除し、その後にバケットを削除します。
### Success
Maven プロジェクトがエラーなしで構築および実行された場合は、正常に完了しています\$1 Java 2.x 用 SDK を使用して最初の Java アプリケーションを正常に構築しました。
### クリーンアップ
このチュートリアルで作成されたリソースをクリーンアップするには、以下を行います。
+ まだ行っていない場合は、[S3 コンソール](https://console.aws.amazon.com/s3/)で、アプリケーションの実行時に作成されたオブジェクトとバケットをすべて削除します。
+ プロジェクトフォルダ (`getstarted`) を削除します。
## 次の手順
これで基本を理解したので、次の事項を学習する準備が整いました。
+ [の使用 Amazon S3](examples-s3.md)
+ 、、および[さまざまなデータベースサービス](examples-databases.md)など[Amazon EC2](examples-ec2.md)、[他の の操作 Amazon Web Services](work-with-services.md) [DynamoDB](examples-dynamodb.md)
+ [SDK を使用する](using.md)
+ [AWS SDK for Java](security.md) のセキュリティ**