AWS Cloud9 は新規顧客には利用できなくなりました。 AWS Cloud9 の既存のお客様は、通常どおりサービスを引き続き使用できます。[詳細はこちら](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)
翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# のチュートリアル AWS Cloud9
を初めてお使いですか AWS Cloud9？ 「[開始方法: ベーシックチュートリアル](tutorials-basic.md)」で IDE の演習を実行します。
これらのチュートリアルとサンプルコードを試して、さまざまなプログラミング言語と AWS サービス AWS Cloud9 で を使用して知識と自信を深めてください。
**Topics**
+ [AWS CLI および aws-shell チュートリアル](sample-aws-cli.md)
+ [AWS CodeCommit チュートリアル](sample-codecommit.md)
+ [Amazon DynamoDB チュートリアル](sample-dynamodb.md)
+ [AWS CDK チュートリアル](sample-cdk.md)
+ [LAMP チュートリアル](sample-lamp.md)
+ [WordPress チュートリアル](sample-wordpress.md)
+ [Java チュートリアル](sample-java.md)
+ [C\$1\$1 チュートリアル](sample-cplusplus.md)
+ [Python チュートリアル](sample-python.md)
+ [.NET チュートリアル](sample-dotnetcore.md)
+ [Node.js チュートリアル](sample-nodejs.md)
+ [PHP チュートリアル](sample-php.md)
+ [Ruby](tutorial-ruby.md)
+ [Go チュートリアル](sample-go.md)
+ [TypeScript チュートリアル](sample-typescript.md)
+ [Docker チュートリアル](sample-docker.md)
+ [関連チュートリアル](#samples-additonal)
# AWS CLI および の aws-shell チュートリアル AWS Cloud9
次のチュートリアルでは、 AWS Cloud9 開発環境で AWS Command Line Interface (AWS CLI)、aws-shell、またはその両方を設定できます。 AWS CLI と aws-shell は、 のすべての部分とやり取りするための一貫したインターフェイスを提供する統合ツールです AWS。 AWS CLI の代わりに を使用して、操作するコマンド AWS マネジメントコンソール をすばやく実行できます。これらのコマンドの一部は AWS、 AWS CLI または で実行できます AWS CloudShell。
の詳細については AWS CLI、[AWS Command Line Interface 「 ユーザーガイド](https://docs.aws.amazon.com/cli/latest/userguide/)」を参照してください。aws-shell については、以下のリソースを参照してください。
+ GitHub ウェブサイトの「[aws-shell](https://github.com/awslabs/aws-shell)」
+ pip ウェブサイトの「[aws-shell](https://pypi.python.org/pypi/aws-shell)」
とやり取り AWS CLI するために で実行できるコマンドのリストについては AWS、[AWS CLI 「 コマンドリファレンス](https://docs.aws.amazon.com/cli/latest/reference/)」を参照してください。`aws` プレフィックスなしでコマンドを起動する以外は AWS CloudShell、 で同じコマンドを使用できます。
このサンプルを作成すると、 AWS アカウントに料金が発生する可能性があります。Amazon EC2 や Amazon S3 などのサービスに対して発生する可能性がある料金も含まれます。詳細については、「[Amazon EC2 料金表](https://aws.amazon.com/ec2/pricing/)」および「[Amazon S3 料金表](https://aws.amazon.com/s3/pricing/)」を参照してください。
**Topics**
+ [前提条件](#sample-aws-cli-prereqs)
+ [ステップ 1: 環境に AWS CLI、aws-shell、またはその両方をインストールする](#sample-aws-cli-install)
+ [ステップ 2: 環境で認証情報管理を設定する](#sample-aws-cli-creds)
+ [ステップ 3: 環境内の AWS CLI または aws-shell を使用して基本的なコマンドを実行する](#sample-aws-cli-run)
+ [ステップ 4: クリーンアップする](#sample-aws-cli-clean-up)
## 前提条件
このサンプルを使用する前に、設定が次の要件を満たしていることを確認します。
+ **既存の AWS Cloud9 EC2 開発環境が必要です。**このサンプルは、Amazon Linux または Ubuntu Server を実行する Amazon EC2 インスタンスに接続された EC2 環境が既にあることを前提としています。別のタイプの環境またはオペレーティングシステムがある場合、このサンプルの指示を関連ツールを設定する必要がある場合があります。詳細については、「[での環境の作成 AWS Cloud9](create-environment.md)」を参照してください。
+ **既存の環境の AWS Cloud9 IDE が既に開いている。**環境を開くと、 はウェブブラウザでその環境の IDE AWS Cloud9 を開きます。詳細については、「[で環境を開く AWS Cloud9](open-environment.md)」を参照してください。
## ステップ 1: 環境に AWS CLI、aws-shell、またはその両方をインストールする
このステップでは、 AWS Cloud9 IDE を使用して AWS CLI、aws-shell、またはその両方を環境にインストールし、操作するコマンドを実行できます AWS。
AWS Cloud9 EC2 開発環境を使用していて、 のみを使用する場合は AWS CLI、「」に進むことができます[ステップ 3: 環境内の AWS CLI または aws-shell を使用して基本的なコマンドを実行する](#sample-aws-cli-run)。これは、 AWS CLI が EC2 環境に既にインストールされており、 AWS アクセス認証情報のセットが環境に既に設定されているためです。詳細については、「[AWS マネージド一時認証情報](security-iam.md#auth-and-access-control-temporary-managed-credentials)」を参照してください。
EC2 環境を使用していない場合は、以下を実行して AWS CLIをインストールします。
1. 環境を開いた状態で、IDE で、 が既にインストール AWS CLI されているかどうかを確認します。ターミナルで **`aws --version`** コマンドを実行します。(新しいターミナルセッションを開始するには、メニューバーで、［ **Window (ウィンドウ)**］ 、［ **New Terminal (新しいターミナル)**］ の順に選択します。) AWS CLI がインストールされている場合、Python のバージョン番号や Amazon EC2 インスタンスまたは独自のサーバーのオペレーティングシステムのバージョン番号などの情報とともに、バージョン番号が表示されます。 AWS CLI がインストールされている場合は、「」に進みます[ステップ 2: 環境で認証情報管理を設定する](#sample-aws-cli-creds)。
1. をインストールするには AWS CLI、 *AWS Command Line Interface ユーザーガイド*[の「 AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)のインストール」を参照してください。たとえば、Amazon Linux を実行するEC2 環境の場合は、ターミナルで次の 3 つのコマンドを 1 つずつ実行して、 AWS CLIをインストールします。
```
sudo yum -y update # Install the latest system updates.
sudo yum -y install aws-cli # Install the AWS CLI.
aws --version # Confirm the AWS CLI was installed.
```
Ubuntu Server を実行する EC2 環境の場合は、ターミナルで代わりに次の 3 つのコマンドを 1 つずつ実行して、 AWS CLIをインストールします。
```
sudo apt update # Install the latest system updates.
sudo apt install -y awscli # Install the AWS CLI.
aws --version # Confirm the AWS CLI was installed.
```
aws-shell をインストールする場合は、以下を実行します。
1. 環境が開いている状態で、IDE で aws-shell が既にインストールされているかどうかをチェックします。ターミナルで **`aws-shell`** コマンドを実行します。(新しいターミナルセッションを開始するには、メニューバーで、［ **Window (ウィンドウ)**］ 、［ **New Terminal (新しいターミナル)**］ の順に選択します。) aws-shell がインストールされている場合は、`aws>` プロンプトが表示されます。aws-shell がインストール済みである場合は、「[ステップ 2: 環境で認証情報管理を設定する](#sample-aws-cli-creds)」に進んでください。
1. aws-shell をインストールするには、pip を使用します。pip を使用するには、Python がインストールされている必要があります。
Python が既にインストールされているかどうかをチェックするには (および必要に応じてインストールするには)、*Python のサンプル*の [ステップ 1: Python をインストールする](sample-python.md#sample-python-install) にある指示に従ってから、このトピックに戻ってください。
pip がインストール済みであるかどうかを確認するには、ターミナルで、**`pip --version`** コマンドを実行します。pip がインストールされている場合は、バージョン番号が表示されます。pip がインストールされていない場合は、ターミナルで次の 3 つのコマンドを 1 つずつ実行して、pip をインストールします。
```
wget https://bootstrap.pypa.io/get-pip.py # Get the pip install file.
sudo python get-pip.py # Install pip. (You might need to run 'sudo python2 get-pip.py' or 'sudo python3 get-pip.py' instead, depending on how Python is installed.)
rm get-pip.py # Delete the pip install file, as it is no longer needed.
```
1. pip を使用して aws-shell をインストールするには、次のコマンドを実行します。
```
sudo pip install aws-shell
```
## ステップ 2: 環境で認証情報管理を設定する
AWS CLI または aws-shell を使用して AWS サービスを呼び出すたびに、呼び出しで一連の認証情報を指定する必要があります。これらの認証情報は、 AWS CLI または aws-shell に、その呼び出しを行うための適切なアクセス許可があるかどうかを決定します。認証情報に適切なアクセス権限がない場合は、呼び出しは失敗します。
AWS Cloud9 EC2 開発環境を使用している場合は、「」に進むことができます[ステップ 3: 環境内の AWS CLI または aws-shell を使用して基本的なコマンドを実行する](#sample-aws-cli-run)。これは、認証情報が既に EC2 環境で設定されているためです。詳細については、「[AWS マネージド一時認証情報](security-iam.md#auth-and-access-control-temporary-managed-credentials)」を参照してください。
EC2 環境を使用していない場合は、手動で環境内に認証情報を保存する必要があります。これを行うには、[の環境 AWS のサービス からの呼び出し AWS Cloud9](credentials.md) の指示を実行してから、このトピックに戻ります。
## ステップ 3: 環境内の AWS CLI または aws-shell を使用して基本的なコマンドを実行する
このステップでは、 環境の AWS CLI または aws-shell を使用して Amazon S3 にバケットを作成し、使用可能なバケットを一覧表示してから、バケットを削除します。
1. aws-shell を使用するがまだ起動していない場合は、`aws-shell` コマンドを実行して aws-shell を起動します。`aws>` プロンプトが表示されます。
1. バケットを作成します。** `aws s3 mb` ** AWS CLI または aws-shell で ** `s3 mb` ** コマンドを実行し、作成するバケットの名前を指定します。この例では、 という名前のバケットを使用します。ここで`cloud9-123456789012-bucket`、 `123456789012`は AWS アカウント ID です。別の名前を使用する場合は、このステップ全体でそれを置き換えてください。
```
aws s3 mb s3://cloud9-123456789012-bucket # For the AWS CLI.
s3 mb s3://cloud9-123456789012-bucket # For the aws-shell.
```
**注記**
バケット名は、 AWS アカウントだけでなく AWS、すべての で一意である必要があります。上記で提案されたバケット名は、一意のバケット名を作成するために便利です。`BucketAlreadyExists` というエラーを含むメッセージが表示された場合は、別のバケット名で再度コマンドを実行する必要があります。
1. 使用可能なバケットを一覧表示します。で ** `aws s3 ls` ** コマンドを実行する AWS CLI か、aws-shell で ** `s3 ls` ** コマンドを実行します。使用可能なバケットのリストが表示されます。
1. バケットを削除します。** `aws s3 rb` ** AWS CLI または aws-shell で ** `s3 rb` ** コマンドを実行し、削除するバケットの名前を指定します。
```
aws s3 rb s3://cloud9-123456789012-bucket # For the AWS CLI.
s3 rb s3://cloud9-123456789012-bucket # For the aws-shell.
```
バケットが削除されたかどうかを確認するには、 で ** `aws s3 ls` ** コマンドを再度実行する AWS CLI か、aws-shell で ** `s3 ls` ** コマンドを再度実行します。削除されたバケットの名前がリストに表示されていないことを確認します。
**注記**
バケットを使用し続ける場合は、削除する必要はありません。詳細については、*Amazon Simple Storage Service ユーザーガイド*の[バケットへのオブジェクトの追加](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html)を参照してください。*AWS CLI コマンドリファレンス*にある [s3 コマンド](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html.html)も参照してください。(バケットを削除しない場合、 AWS アカウントに対して継続的な料金が発生する可能性があることに注意してください）。
の実験を続行するには AWS CLI、*AWS Command Line Interface 「 ユーザーガイド*」の[「Amazon Web Services の使用](https://docs.aws.amazon.com/cli/latest/userguide/chap-working-with-services.html)」および[AWS CLI 「 コマンドリファレンス](https://docs.aws.amazon.com/cli/latest/reference/)」を参照してください。aws-shell を使用して実験を続行するには、[AWS CLI コマンドリファレンス](https://docs.aws.amazon.com/cli/latest/reference/)を参照してください。コマンドをスタートするときに `aws` プレフィックスを付けないように注意してください。
## ステップ 4: クリーンアップする
aws-shell を使用している場合、**`.exit`** コマンドまたは **`.quit`** コマンドを実行して使用を停止できます。
このサンプルの使用が完了したら、 AWS アカウントへの継続的な課金を防ぐには、環境を削除する必要があります。手順については、「[での環境の削除 AWS Cloud9](delete-environment.md)」を参照してください。
# AWS CodeCommit の チュートリアル AWS Cloud9
AWS CodeCommit チュートリアルを使用して、CodeCommit のリモートコードリポジトリとやり取りする AWS Cloud9 開発環境を設定できます。CodeCommit は、 AWS クラウドでの Git リポジトリのプライベートな保存と管理を有効にするソースコード制御サービスです。CodeCommit の詳細については、[AWS CodeCommit ユーザーガイド](https://docs.aws.amazon.com/codecommit/latest/userguide/)を参照してください。
このチュートリアルに従い、このサンプルを作成すると、 に料金が発生する可能性があります AWS アカウント。これには、Amazon EC2 や CodeCommit などのサービスで発生する可能性がある料金も含まれます。詳細については、「[Amazon EC2 コスト](https://aws.amazon.com/ec2/pricing/)」および「[AWS CodeCommit コスト](https://aws.amazon.com/codecommit/pricing/)」を参照してください。
+ [前提条件](#sample-codecommit-prereqs)
+ [ステップ 1: 必要なアクセス許可を持つ IAM グループを設定する](#sample-codecommit-permissions)
+ [ステップ 2: でリポジトリを作成する AWS CodeCommit](#sample-codecommit-create-repo)
+ [ステップ 3: 環境をリモートリポジトリに接続する](#sample-codecommit-connect-repo)
+ [ステップ 4: リモートリポジトリのクローンを環境に作成する](#sample-codecommit-clone-repo)
+ [ステップ 5: リポジトリにファイルを追加する](#sample-codecommit-add-files)
+ [ステップ 6: クリーンアップする](#sample-codecommit-clean-up)
## 前提条件
このサンプルを使用する前に、設定が次の要件を満たしていることを確認します。
+ **既存の AWS Cloud9 EC2 開発環境が必要です。**このサンプルは、Amazon Linux または Ubuntu Server を実行する Amazon EC2 インスタンスに接続された EC2 環境が既にあることを前提としています。別のタイプの環境またはオペレーティングシステムがある場合、このサンプルの指示を関連ツールを設定する必要がある場合があります。詳細については、「[での環境の作成 AWS Cloud9](create-environment.md)」を参照してください。
+ **既存の環境の AWS Cloud9 IDE が既に開いている。**環境を開くと、 はウェブブラウザでその環境の IDE AWS Cloud9 を開きます。詳細については、「[で環境を開く AWS Cloud9](open-environment.md)」を参照してください。
## ステップ 1: 必要なアクセス許可を持つ IAM グループを設定する
AWS 認証情報が の管理者ユーザーに関連付けられていて AWS アカウント、そのユーザーを使用して CodeCommit を操作する場合、[「」のステップ 2: リポジトリを作成する AWS CodeCommit](#sample-codecommit-create-repo)「」に進みます。
このステップは、[AWS マネジメントコンソール](#sample-codecommit-permissions-console) または [AWS コマンドラインインターフェイス (AWS CLI)](#sample-codecommit-permissions-cli) を使って完了できます。
### コンソールを使用して、必要なアクセス許可を持つ IAM グループを設定する
1. まだサインインしていない場合は AWS マネジメントコンソール、 にサインインします。
このステップでは、 AWS アカウントの管理者ユーザーの認証情報を使用してサインインすることをお勧めします。これが実行できない場合は、 AWS アカウント 管理者にお問い合わせください。
1. [IAM コンソール] を開きます。これを行うには、コンソールのナビゲーションバーで、［**サービス**］を選択します。次に、**[IAM]** を選択します。
1. ［**グループ**］を選択します。
1. グループの名前を選択します。
1. ［**アクセス許可**］タブの［**管理ポリシー**］で［**ポリシーのアタッチ**］を選択します。
1. ポリシー名のリストで、次のいずれかのボックスを選択します。
+ **AWSCodeCommitPowerUser** を選択すると、CodeCommit のすべての機能とリポジトリ関連リソースにアクセスできます。ただし、これによりCodeCommit リポジトリを削除したり AWS のサービス、Amazon CloudWatch Events などの他の でリポジトリ関連のリソースを作成または削除したりすることはできません。
+ **AWSCodeCommitFullAccess** を選択して、 の CodeCommit リポジトリおよび関連リソースを完全に制御します AWS アカウント。これにはリポジトリを削除する機能も含まれます。
どちらのポリシー名もリストに表示されない場合は、**[Filter]** (フィルター) ボックスにポリシー名を入力して表示させます。
1. ［**ポリシーをアタッチ**] を選択します。
これらの AWS 管理ポリシーがグループに付与するアクセス許可のリストを確認するには、「 *AWS CodeCommit ユーザーガイド*」の[AWS 「 の 管理 (事前定義) ポリシー AWS CodeCommit](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html#managed-policies)」を参照してください。
ステップ [2: リポジトリを作成する AWS CodeCommit](#sample-codecommit-create-repo)に進みます。
### を使用して必要なアクセス許可を持つ IAM グループを設定する AWS CLI
IAM `attach-group-policy` コマンドを実行し、グループの名前と、必要なアクセス許可を記述する AWS 管理ポリシーの Amazon リソースネーム (ARN) を指定します。構文は次のとおりです。
```
aws iam attach-group-policy --group-name MyGroup --policy-arn POLICY_ARN
```
前述のコマンドで、`MyGroup` をグループの名前に置き換えます。を AWS マネージドポリシーの ARN `POLICY_ARN`に置き換えます。
+ `arn:aws:iam::aws:policy/AWSCodeCommitPowerUser` を選択すると、CodeCommit のすべての機能とリポジトリ関連リソースにアクセスできます。ただし、CodeCommit リポジトリを削除したり AWS のサービス、Amazon CloudWatch Events などの他の でリポジトリ関連のリソースを作成または削除したりすることはできません。
+ `arn:aws:iam::aws:policy/AWSCodeCommitFullAccess` は、 の CodeCommit リポジトリおよび関連リソースを完全に制御できます AWS アカウント。これにはリポジトリを削除する機能も含まれます。
これらの AWS 管理ポリシーがグループに付与するアクセス許可のリストを確認するには、「 *AWS CodeCommit ユーザーガイド*」の[AWS 「 の 管理 (事前定義) ポリシー AWS CodeCommit](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html#managed-policies)」を参照してください。
## ステップ 2: CodeCommit でリポジトリを作成する
このステップでは、CodeCommit コンソールを使用して CodeCommit にリモートコードリポジトリを作成します。
すでに CodeCommit リポジトリがある場合は、「[ステップ 3: 環境をリモートリポジトリに接続する](#sample-codecommit-connect-repo)」に進みます。
このステップは、[AWS マネジメントコンソール](#sample-codecommit-create-repo-console)または [AWS コマンドラインインターフェース(AWS CLI)](#sample-codecommit-create-repo-cli)を使って完了できます。
### コンソールを使用して CodeCommit でリポジトリを作成する
1. 前のステップで管理者ユーザー AWS マネジメントコンソール として にサインインしていて、管理者ユーザーを使用してリポジトリを作成したくないとします。次に、 からサインアウトします AWS マネジメントコンソール。
1. [https://console.aws.amazon.com/codecommit](https://console.aws.amazon.com/codecommit) で CodeCommit コンソールを開きます。
1. コンソールのナビゲーションバーで、リージョンセレクタを使用して、リポジトリの作成先の AWS リージョン を選択します (例: **米国東部 (オハイオ**)。
1. ウェルカムページが表示された場合は、［**今すぐ始める**］を選択します。それ以外の場合は、［**リポジトリの作成**］を選択します。
1. **[Create repository]** (リポジトリの作成) ページの **[Repository name]** (レポジトリ名) に、新しいレポジトリの名前を入力します (例: `MyDemoCloud9Repo`)。(別の名前を選択する場合は、このサンプル全体でそれに置き換えてください。)
1. (オプション) **[Description]** (説明) に、リポジトリに関する説明を入力します。例えば、`This is a demonstration repository for the AWS Cloud9 sample.` と入力します。
1. ［**リポジトリの作成**］を選択します。［**リポジトリに接続**］ペインが表示されます。［**閉じる**］を選択します。このトピックの後半で別の方法でリポジトリに接続するためです。
「[ステップ 3: 環境をリモートリポジトリに接続する](#sample-codecommit-connect-repo)」に進みます。
### を使用して CodeCommit でリポジトリを作成する AWS CLI
AWS CodeCommit `create-repository` コマンドを実行します。リポジトリの名前、オプションの説明、リポジトリ AWS リージョン を作成する を指定します。
```
aws codecommit create-repository --repository-name MyDemoCloud9Repo --repository-description "This is a demonstration repository for the AWS Cloud9 sample." --region us-east-2
```
前述のコマンドで、`us-east-2` を AWS リージョン の ID に置き換えてリポジトリを作成します。サポートされているリージョンのリストについては、「Amazon Web Services 全般のリファレンス」の「[AWS CodeCommit](https://docs.aws.amazon.com/general/latest/gr/rande.html#codecommit_region)」を参照してください。
(別のリポジトリ名を使用する場合は、このサンプル全体でそれに置き換えてください。)
## ステップ 3: 環境をリモートリポジトリに接続する
このステップでは、IDE AWS Cloud9 を使用して、前のステップで作成または識別した CodeCommit リポジトリに接続します。
**注記**
ビジュアルインターフェイスを使って Git を操作したい場合は、リモートリポジトリをクローンすることができます。次に、IDE の [Git パネル](source-control-gitpanel.md)機能を使用してファイルを追加できます。
使用する AWS Cloud9 開発環境の種類に応じて、次の一連の手順のいずれかを完了します。
****
| **環境タイプ** | **以下の手順に従います** |
| --- | --- |
| EC2 環境 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/cloud9/latest/user-guide/sample-codecommit.html) |
| SSH 環境 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/cloud9/latest/user-guide/sample-codecommit.html) |
## ステップ 4: リモートリポジトリのクローンを環境に作成する
このステップでは、IDE AWS Cloud9 を使用して CodeCommit のリモートリポジトリを環境にクローンします。
リポジトリのクローンを作成するには、**`git clone`** コマンドを実行します。`CLONE_URL` をリポジトリのクローン URL に置き換えます。
```
git clone CLONE_URL
```
EC2 環境には、`https://` で始まる HTTPS クローン URL を指定します。SS 環境 には、`ssh://` で始まる SSH クローン URL を指定します。
リポジトリの完全なクローン URL を取得するには、*AWS CodeCommit 「 ユーザーガイド*[」の AWS CodeCommit 「コンソールを使用してリポジトリの詳細を表示する](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-view-repository-details.html#how-to-view-repository-details-console)」を参照してください。
リポジトリにファイルがない場合は、「`You appear to have cloned an empty repository.`」のような警告メッセージが表示されます。これは想定される動作です。これについては後で説明します。
## ステップ 5: リポジトリにファイルを追加する
このステップでは、 AWS Cloud9 環境にクローンしたリポジトリに 3 つのシンプルなファイルを作成します。次に、クローンしたリポジトリの Git ステージング領域にファイルを追加します。最後に、ステージングされたファイルをコミットして、そのコミットを CodeCommit のリモートリポジトリにプッシュします。
クローンされたリポジトリにすでにファイルが含まれている場合、操作は不要で、このサンプルの残りの部分はスキップできます。
**リポジトリにファイルを追加するには**
1. 新しいファイルを作成します。メニューバーで［**File (ファイル)**］、［**New File (新規ファイル)**］の順に選択します。
1. ファイルに次のコンテンツを入力し、**File**, **Save** を選択して、 AWS Cloud9 環境の `MyDemoCloud9Repo` ディレクトリ`bird.txt`に としてファイルを保存します。
```
bird.txt
--------
Birds are a group of endothermic vertebrates, characterized by feathers,
toothless beaked jaws, the laying of hard-shelled eggs, a high metabolic
rate, a four-chambered heart, and a lightweight but strong skeleton.
```
**注記**
このファイルが正しいディレクトリに保存されたことを確認するには、**[Save As]** (名前を付けて保存)ダイアログボックスで `MyDemoCloud9Repo` フォルダを選択します。次に、**[Folder] ** (フォルダ) に `/MyDemoCloud9Repo` が表示されていることを確認します。
1. 次の内容で、`insect.txt` および `reptile.txt` という名前のファイルを 2 つ作成します。ファイルを `MyDemoCloud9Repo` ディレクトリに保存します。
```
insect.txt
----------
Insects are a class of invertebrates within the arthropod phylum that
have a chitinous exoskeleton, a three-part body (head, thorax, and abdomen),
three pairs of jointed legs, compound eyes, and one pair of antennae.
```
```
reptile.txt
-----------
Reptiles are tetrapod (four-limbed vertebrate) animals in the class
Reptilia, comprising today's turtles, crocodilians, snakes,
amphisbaenians, lizards, tuatara, and their extinct relatives.
```
1. ターミナルで、**`cd`** コマンドを実行して `MyDemoCloud9Repo` ディレクトリに切り替えます。
```
cd MyDemoCloud9Repo
```
1. **`git status`** コマンドを実行して、ファイルが正しく `MyDemoCloud9Repo` ディレクトリに保存されたことを確認します。3 つのファイルはすべて追跡されていないファイルとして表示されます。
```
Untracked files:
(use "git add ..." to include in what will be committed)
bird.txt
insect.txt
reptile.txt
```
1. **`git add`** コマンドを実行して、ファイルを Git ステージング領域に追加します。
```
git add --all
```
1. **`git status`** コマンドを実行して、ファイルが正しく Git ステージング領域に追加されたことを確認します。3 つのファイルがすべてコミットされる変更としてリストされます。
```
Changes to be committed:
(use "git rm --cached ..." to unstage)
new file: bird.txt
new file: insect.txt
new file: reptile.txt
```
1. **`git commit`** コマンドを実行して、ステージングされたファイルをコミットします。
```
git commit -m "Added information about birds, insects, and reptiles."
```
1. **`git push`** コマンドを実行して、コミットを CodeCommit のリモートリポジトリにコマンドをプッシュします。
```
git push -u origin master
```
1. ファイルが正常にプッシュされたかどうかを確認します。CodeCommit コンソール ([https://console.aws.amazon.com/codecommit](https://console.aws.amazon.com/codecommit)) を開きます (まだ開いていない場合)。
1. 右上のナビゲーションバーで、リポジトリを作成した AWS リージョン を選択します (例: **米国東部 (オハイオ)**)。
1. ［**ダッシュボード**］ページで、［**MyDemoCloud9Repo**］を選択します。3 つのファイルが表示されます。
CodeCommit リポジトリの試用を続行するには、*AWS CodeCommit ユーザーガイド* の「[リポジトリの内容を参照する](https://docs.aws.amazon.com/codecommit/latest/userguide/getting-started-cc.html#getting-started-cc-browse)」を参照してください。
Git を初めて使用する場合で CodeCommit リポジトリに手を加えたくない場合は、[[Git を試す]](https://try.github.io/) ウェブサイトのサンプル Git リポジトリを試してください。
## ステップ 6: クリーンアップする
このサンプルの使用が完了した AWS アカウント 後に に継続的に課金されないようにするには、CodeCommit リポジトリを削除します。手順については、*AWS CodeCommit 「 ユーザーガイド*[」の AWS CodeCommit 「リポジトリの削除](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-delete-repository.html)」を参照してください。
必ず環境も削除してください。手順については、「[環境の削除](delete-environment.md)」を参照してください。
# の Amazon DynamoDB チュートリアル AWS Cloud9
このチュートリアルでは、Amazon DynamoDB と連携する AWS Cloud9 開発環境を設定できます。
DynamoDB は、フルマネージド型の NoSQL データベースサービスです。DynamoDB を使用して、任意の量のデータを保存および取得できるデータベーステーブルを作成し、任意のレベルのリクエストトラフィックを処理できます。DynamoDB によって自動的に、そのテーブルのデータとトラフィックが多数のサーバーに分散されます。サーバーの数は、指定のリクエスト容量と保存されているデータを処理するのに十分であるように選択されます。このような分散処理の間も、パフォーマンスは一定で、高速です。詳細については、 AWS ウェブサイトの[「Amazon DynamoDB](https://aws.amazon.com/dynamodb/)」を参照してください。
このサンプルを作成すると、 AWS アカウントに料金が発生する可能性があります。これには、Amazon EC2 や DynamoDB などのサービスで発生する可能性がある料金も含まれます。詳細については、「[Amazon EC2 料金表](https://aws.amazon.com/ec2/pricing/)」および「[Amazon DynamoDB 料金表](https://aws.amazon.com/dynamodb/pricing/)」を参照してください。
その他の AWS データベースサービスの詳細については、 AWS ウェブサイトの[Amazon Relational Database Service (RDS)](https://aws.amazon.com/rds/)」、[Amazon ElastiCache](https://aws.amazon.com/elasticache/)」、および[「Amazon Redshift](https://aws.amazon.com/redshift/)」を参照してください。 AWS ウェブサイトで[AWS Database Migration Service](https://aws.amazon.com/dms/)も参照してください。
+ [前提条件](#sample-dynamodb-prereqs)
+ [ステップ 1: AWS CLI、 AWS CloudShell、またはその両方を環境にインストールして設定する](#sample-dynamodb-cli-setup)
+ [ステップ 2: テーブルを作成する](#sample-dynamodb-create-table)
+ [ステップ 3: テーブルに 1 つの項目を追加する](#sample-dynamodb-add-item)
+ [ステップ 4: テーブルに複数の項目を追加する](#sample-dynamodb-add-items)
+ [ステップ 5: グローバルセカンダリインデックスを作成する](#sample-dynamodb-create-index)
+ [ステップ 6: テーブルから項目を取得する](#sample-dynamodb-get-items)
+ [ステップ 7: クリーンアップする](#sample-dynamodb-clean-up)
## 前提条件
このサンプルを使用する前に、設定が次の要件を満たしていることを確認します。
+ **既存の AWS Cloud9 EC2 開発環境が必要です。**このサンプルは、Amazon Linux または Ubuntu Server を実行する Amazon EC2 インスタンスに接続された EC2 環境が既にあることを前提としています。別のタイプの環境またはオペレーティングシステムがある場合、このサンプルの指示を関連ツールを設定する必要がある場合があります。詳細については、「[での環境の作成 AWS Cloud9](create-environment.md)」を参照してください。
+ **既存の環境の AWS Cloud9 IDE が既に開いている。**環境を開くと、 はウェブブラウザでその環境の IDE AWS Cloud9 を開きます。詳細については、「[で環境を開く AWS Cloud9](open-environment.md)」を参照してください。
## ステップ 1: 環境に AWS CLI、 AWS CloudShell、またはその両方をインストールして設定する
このステップでは、IDE AWS Cloud9 を使用して AWS CLI、、またはその両方を環境にインストールして設定し AWS CloudShell、コマンドを実行して DynamoDB とやり取りできるようにします。次に、 AWS CLI を使用してベーシックな DynamoDB コマンドを実行し、インストールと設定をテストします。
1. AWS CLI または の認証情報管理をセットアップ AWS CloudShell し AWS CLI、、 AWS CloudShell、またはその両方を環境にインストールするには、「」および[AWS CLIAWS CloudShell 「サンプル](sample-aws-cli.md)」のステップ 1 と 2 に従って、このトピックに戻ります。環境に AWS CLI、、 AWS CloudShellまたはその両方を既にインストールして設定している場合は、再度実行する必要はありません。
1. 、aws-shell、またはその両方のインストールと設定をテストするには AWS CLI、環境のターミナルセッションから DynamoDB** `list-tables` ** コマンドを実行して、既存の DynamoDB テーブルがある場合は一覧表示します。新しいターミナルセッションを開始するには、メニューバーで、[**Windows (ウィンドウ)**]、[**New Terminal (新しいターミナル)**] の順に選択します。
```
aws dynamodb list-tables # For the AWS CLI.
dynamodb list-tables # For the aws-shell.
```
**注記**
このサンプルでは、aws-shell を使用している場合に `aws` で始まる各コマンドの `aws` を省略します。aws-shell を開始するには、**`aws-shell`** コマンドを実行します。aws-shell の使用を停止するには、**`.exit`** コマンドまたは **`.quit`** コマンドを実行します。
このコマンドが正常に実行されると、既存の DynamoDB テーブル (ある場合) のリストが `TableNames` 配列として出力されます。まだ DynamoDB テーブルがない場合、`TableNames` 配列は空になります。
```
{
"TableNames": []
}
```
DynamoDB テーブルがある場合は、`TableNames` 配列にテーブル名のリストが表示されます。
## ステップ 2: テーブルを作成する
このステップでは、DynamoDB でテーブルを作成してテーブルの名前、レイアウト、シンプルプライマリキー、データスループット設定を指定します。
`Weather` というこのサンプルテーブルには、アメリカのいくつかの都市の天気予報に関する情報が含まれています。このテーブルには、以下のタイプの情報 (DynamoDB では個々の情報は*属性*と呼ばれます) が保持されます。
+ 必須の一意の都市 ID (`CityID`)
+ 必須の予報日 (`Date`)
+ 都市名 (`City`)
+ 州名 (`State`)
+ 予測天気 (`Conditions`)
+ 予測温度 (`Temperatures`)
+ 予測最高気温、華氏 (`HighF`)
+ 予測最低気温、華氏 (`LowF`)
テーブルを作成するには、IDE AWS Cloud9 のターミナルセッションで DynamoDB** `create-table` ** コマンドを実行します。
```
aws dynamodb create-table \
--table-name Weather \
--attribute-definitions \
AttributeName=CityID,AttributeType=N AttributeName=Date,AttributeType=S \
--key-schema \
AttributeName=CityID,KeyType=HASH AttributeName=Date,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5
```
このコマンドで:
+ `--table-name` はテーブル名を表します (このサンプルでは `Weather`)。テーブル名は、アカウント AWS 内の各 AWS リージョン内で一意である必要があります。
+ `--attribute-definitions` はテーブル項目を一意に識別するために使用する属性を表します。このテーブルの各項目は、ISO-8601 形式の文字列として表される数字の `ID` 属性と `Date` 属性の組み合わせで一意に識別されます。
+ `--key-schema` はテーブルのキースキーマを表します。このテーブルには `CityID` と `Date` の複合プライマリキーがあります。つまり、テーブルの各項目は `CityID` 属性値と `Date` 属性値を持つ必要がありますが、テーブル内で `CityID` 属性値と `Date` 属性値が両方とも同じ 2 つの項目が存在することはできません。
+ `--provisioned-throughput` はテーブルの読み取り/書き込み容量を表します。DynamoDB では、サイズが 4 KB までの項目について 1 秒あたり最大 5 つの強力な整合性のある読み込み、またはサイズが 4 KB までの項目について 1 秒あたり最大 5 つの結果整合性のある読み込みが許可されます。また、DynamoDB ではサイズが 1 KB までの項目について 1 秒あたり最大 5 回の書き込みが許可されます。
**注記**
プロビジョニングされたスループットを高く設定すると、 AWS アカウントに追加料金が発生する可能性があります。
この件および他の DynamoDB のコマンドの詳細については、*AWS CLI コマンドリファレンス*の「[dynamodb](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/index.html)」を参照してください。
このコマンドが成功した場合、作成する新しいテーブルに関する概要情報が表示されます。テーブルが正常に作成されたことを確認するには、テーブルの名前 (`--table-name`) を指定して DynamoDB** `describe-table` ** コマンドを実行します。
```
aws dynamodb describe-table --table-name Weather
```
テーブルが正常に作成されると、`TableStatus` の値が `CREATING` から `ACTIVE` に変わります。テーブルが正常に作成されてからこのステップの先に進んでください。
## ステップ 3: テーブルに 1 つの項目を追加する
このステップでは、作成したテーブルに項目を追加します。
1. `weather-item.json` という名前のファイルを作成し、次の内容を記述します。新規ファイルを作成するには、メニューバーで [**File (ファイル)**]、[**New File (新規ファイル)**] の順に選択します。ファイルを保存するには、［**File (ファイル)**］、［**Save (保存)**］の順に選択します。
```
{
"CityID": { "N": "1" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "46" }
}
}
}
```
このコードでは、`N` は数値である属性値です。`S` は文字列の属性値です。`M` はマップ属性であり、一連の属性と値のペアです。項目を操作する場合は常に属性のデータ型を指定する必要があります。その他の使用可能な属性のデータ型については、[データ型](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes)の*Amazon DynamoDB デベロッパーガイド*のデータ型を参照してください。
1. テーブル名 (`--table-name`) と JSON 形式の項目のパス (`--item`) を指定して DynamoDB** `put-item` ** コマンドを実行します。
```
aws dynamodb put-item \
--table-name Weather \
--item file://weather-item.json
```
コマンドが成功すると、エラーなしで実行され、確認メッセージは表示されません。
1. テーブルの現在のコンテンツを確認するには、テーブルの名前 (`--table-name`) を指定して DynamoDB** `scan` ** コマンドを実行します。
```
aws dynamodb scan --table-name Weather
```
コマンドが成功した場合は、テーブルおよび追加した項目に関する概要情報が表示されます。
## ステップ 4: テーブルに複数の項目を追加する
このステップでは、`Weather` テーブルに複数の項目を追加します。
1. `more-weather-items.json` という名前のファイルを作成し、次の内容を記述します。
```
{
"Weather": [
{
"PutRequest": {
"Item": {
"CityID": { "N": "1" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "52" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "1" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Seattle" },
"State": { "S": "WA" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "49" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Thunderstorms" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "43" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "51" },
"LowF": { "N": "41" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "2" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Portland" },
"State": { "S": "OR" },
"Conditions": { "S": "Rain Showers" },
"Temperatures": { "M": {
"HighF": { "N": "49" },
"LowF": { "N": "39" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-12" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Rain" },
"Temperatures": { "M": {
"HighF": { "N": "59" },
"LowF": { "N": "40" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-13" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Partly Sunny" },
"Temperatures": { "M": {
"HighF": { "N": "54" },
"LowF": { "N": "37" }
}
}
}
}
},
{
"PutRequest": {
"Item": {
"CityID": { "N": "3" },
"Date": { "S": "2017-04-14" },
"City": { "S": "Portland" },
"State": { "S": "ME" },
"Conditions": { "S": "Mostly Sunny" },
"Temperatures": { "M": {
"HighF": { "N": "53" },
"LowF": { "N": "37" }
}
}
}
}
}
]
}
```
このコードでは、前のステップで定義された単一の項目と同様に、8 つの `Item` オブジェクトがテーブルに追加する 8 つの項目を定義します。ただし、次のステップで DynamoDB**`batch-write-item`** コマンドを実行する際に、JSON 形式のオブジェクトを指定する必要があります。各 `Item` オブジェクトが `PutRequest` オブジェクトに含められます。次に、これらの `PutRequest` オブジェクトを、テーブルと同じ名前の親配列に含める必要があります。
1. 追加する JSON 形式の項目のパス (`--request-items`) を指定して DynamoDB** `batch-write-item` ** コマンドを実行します。
```
aws dynamodb batch-write-item \
--request-items file://more-weather-items.json
```
コマンドが成功すると、次のメッセージが表示され、項目が正常に追加されたことを確認できます。
```
{
"UnprocessedItems": {}
}
```
1. テーブルの現在のコンテンツを確認するには、DynamoDB** `scan` ** コマンドをもう一度実行します。
```
aws dynamodb scan --table-name Weather
```
コマンドが成功した場合は、9 件の項目が表示されます。
## ステップ 5: グローバルセカンダリインデックスを作成する
DynamoDB** `scan` ** コマンドを実行して項目に関する情報を取得するには、特にテーブルのサイズが大きくなった場合や、取得する情報のタイプが複雑な場合は、時間がかかる場合があります。1 つ以上のセカンダリインデックスを作成して、処理速度を上げ情報を簡単に取得できるようにします。このステップでは、これを行うために DynamoDB がサポートしている 2 種類のセカンダリインデックスについて学習します。これらは、*ローカルセカンダリインデックス*および*グローバルセカンダリインデックス*と呼ばれます。ここではグローバルセカンダリインデックスを作成します。
これらのセカンダリインデックスの種類を理解するには、最初にテーブルの項目を一意に識別するプライマリキーの詳細について理解する必要があります。DynamoDB では、*シンプルプライマリキー*または*複合プライマリキー*がサポートされています。シンプルプライマリキーには単一の属性があり、その属性値はテーブルの項目ごとに一意である必要があります。この属性は、*パーティションキー* (または*ハッシュ属性*) とも呼ばれ、DynamoDB はこれを使用して項目をパーティション化し、アクセスを高速化します。また、テーブルで 2 つの属性を組み合わせた複合プライマリキーを持つこともできます。最初の属性はパーティションキーであり、2 番目の属性は*ソートキー* (*範囲属性*ともいいます) です。複合プライマリキーがあるテーブルの場合、2 つの項目が同じパーティションキー値を持つことはできますが、ソートキー値も同じにはできません。`Weather` テーブルには複合プライマリキーがあります。
ローカルセカンダリインデックスは、テーブル自体と同じパーティションキーを持ちますが、このインデックスタイプでは異なるソートキーを持つことができます。グローバルセカンダリインデックスは、テーブル自体とはどちらも異なるパーティションキーとソートキーを持つことができます。
たとえば、`Weather` 項目にアクセスするプライマリキーに `CityID` を既に使用しているとします。`Weather` 項目に `State` を使用してアクセスするには、パーティションキー `CityID` (テーブル自体と同じである必要があります) とソートキー `State` を持つローカルセカンダリインデックスを作成できます。`Weather` 項目に `City` を使用してアクセスするには、パーティションキー `City` とソートキー `Date` を持つグローバルセカンダリインデックスを作成できます。
ローカルセカンダリインデックスは、テーブルを作成するときにのみ作成できます。`Weather` テーブルが既に存在するため、そこにローカルセカンダリインデックスを追加することはできません。ただし、グローバルセカンダリインデックスを追加することはできます。1 つ追加してみましょう。
**注記**
セカンダリインデックスを作成すると、 AWS アカウントに追加料金が発生する可能性があります。
1. `weather-global-index.json` という名前のファイルを作成し、次の内容を記述します。
```
[
{
"Create": {
"IndexName": "weather-global-index",
"KeySchema": [
{
"AttributeName": "City",
"KeyType": "HASH"
},
{
"AttributeName": "Date",
"KeyType": "RANGE"
}
],
"Projection": {
"ProjectionType": "INCLUDE",
"NonKeyAttributes": [
"State",
"Conditions",
"Temperatures"
]
},
"ProvisionedThroughput": {
"ReadCapacityUnits": 5,
"WriteCapacityUnits": 5
}
}
}
]
```
このコードでは:
+ グローバルセカンダリインデックスの名前は `weather-global-index` です。
+ `City` 属性はパーティションキー (ハッシュ属性)、`Date` 属性はソートキー (範囲属性) です。
+ `Projection` は、このインデックスを使用したテーブル検索に一致する各項目について、デフォルトで (ハッシュ属性と範囲属性に加えて) 取得する属性を定義します。このサンプルでは、`State`、`Conditions`、`HighF` (`Temperatures` の一部)、および `LowF` (`Temperatures` のい一部) 属性 (および `City` 属性と `Date` 属性) は、一致する項目ごとに取得されます。
+ テーブルと同様に、グローバルセカンダリインデックスではプロビジョニングされたスループット設定を定義する必要があります。
+ `IndexName`、`KeySchema`、`Projection`、および `ProvisionedThroughput` 設定が `Create` オブジェクトに含まれている必要があります。このオブジェクトは、次のステップで DynamoDB** `update-table` **コマンドを実行して作成するグローバルセカンダリインデックスを定義します。
1. DynamoDB ** `update-table` **コマンドを実行します。
```
aws dynamodb update-table \
--table-name Weather \
--attribute-definitions \
AttributeName=City,AttributeType=S AttributeName=Date,AttributeType=S \
--global-secondary-index-updates file://weather-global-index.json
```
このコマンドで:
+ `--table-name` は更新するテーブルの名前です。
+ `--attribute-definitions` はインデックスに含める属性です。パーティションキーは常にリストの最初に表示され、ソートキーは常にリストの 2 番目に表示されます。
+ `--global-secondary-index-updates` はグローバルセカンダリインデックスを定義するファイルへのパスです。
このコマンドが成功した場合、作成する新しいグローバルセカンダリインデックスに関する概要情報が表示されます。グローバルセカンダリインデックスが正常に作成されたことを確認するには、テーブルの名前 (`--table-name`) を指定して DynamoDB** `describe-table` ** コマンドを実行します。
```
aws dynamodb describe-table --table-name Weather
```
グローバルセカンダリインデックスが正常に作成された場合、`TableStatus` の値が `UPDATING` から `ACTIVE` に変わり、`IndexStatus` の値が `CREATING` から `ACTIVE` に変わります。グローバルセカンダリインデックスが正常に作成されてからこのステップの先に進んでください。これには数分間かかる場合があります。
## ステップ 6: テーブルから項目を取得する
テーブルから項目を取得する方法は複数あります。このステップでは、テーブルのプライマリキー、テーブルのその他の属性、およびグローバルセカンダリインデックスをそれぞれ使用して項目を取得します。
### 項目のプライマリキーの値に基づいてテーブルから単一の項目を取得するには
項目のプライマリキーバリューがわかっている場合は、DynamoDB コマンド ** `get-item` **、** `scan` **、または ** `query` ** を実行して一致する項目を取得できます。各コマンドの主な相違点は次のとおりです。
+ **`get-item`** は、指定されたプライマリキーを持つ項目の属性のセットを返します。
+ **`scan`** は、テーブルまたはセカンダリインデックスの各項目にアクセスして、1 つ以上の項目または項目属性を返します。
+ **`query`** はプライマリキー値に基づいて項目を探します。複合プライマリキー (パーティションキーとソートキー) のあるテーブルまたはセカンダリインデックスをクエリできます。
このサンプルで、これらのコマンドをそれぞれ使用して、`CityID` 属性の値が `1`、`Date` 属性の値が `2017-04-12` の項目を取得する方法を説明します。
1. DynamoDB** `get-item` ** コマンドを実行するには、テーブルの名前 (`--table-name`)、プライマリキーバリュー (`--key`)、および表示する項目の属性値 (`--projection-expression`) を指定します。`Date` は DynamoDBで予約されたキーワードであるため、`Date` 属性値のエイリアス (`--expression-attribute-names`) も指定する必要があります (`State` も予約されたキーワードであり、このためのエイリアスは後のステップで指定します)。
```
aws dynamodb get-item \
--table-name Weather \
--key '{ "CityID": { "N": "1" }, "Date": { "S": "2017-04-12" } }' \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
このコマンドや他のコマンドで、項目の属性をすべて表示するには、`--projection-expression` を含めません。このサンプルでは、`--projection-expression` を含めていないため、`--expression-attribute-names` を含める必要もありません。
```
aws dynamodb get-item \
--table-name Weather \
--key '{ "CityID": { "N": "1" }, "Date": { "S": "2017-04-12" } }'
```
1. DynamoDB** `scan` ** コマンドを実行するには、以下を指定します。
+ テーブルの名前 (`--table-name`)。
+ 実行する検索 (`--filter-expression`)。
+ 使用する検索基準 (`--expression-attribute-values`)。
+ 一致した項目で表示する属性の種類 (`--select`)。
+ 表示する項目の属性値 (`--projection-expression`)。
+ 属性に DynamoDB の予約済みキーワードが使用されている場合、その属性のエイリアス (`--expression-attribute-names`)。
```
aws dynamodb scan \
--table-name Weather \
--filter-expression "(CityID = :cityID) and (#D = :date)" \
--expression-attribute-values \
'{ ":cityID": { "N": "1" }, ":date": { "S": "2017-04-12" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
1. DynamoDB** `query` ** コマンドを実行するには、以下を指定します。
+ テーブルの名前 (`--table-name`)。
+ 実行する検索 (`--key-condition-expression`)。
+ 検索で使用する属性値 (`--expression-attribute-values`)。
+ 一致した項目で表示する属性の種類 (`--select`)。
+ 表示する項目の属性値 (`--projection-expression`)。
+ 属性に DynamoDB の予約済みキーワードが使用されている場合、その属性のエイリアス (`--expression-attribute-names`)。
```
aws dynamodb query \
--table-name Weather \
--key-condition-expression "(CityID = :cityID) and (#D = :date)" \
--expression-attribute-values \
'{ ":cityID": { "N": "1" }, ":date": { "S": "2017-04-12" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression \
"City, #D, Conditions, Temperatures.HighF, Temperatures.LowF" \
--expression-attribute-names '{ "#D": "Date" }'
```
結果を取得するためにスキャンする必要がある項目数が、**`scan`** コマンドでは 9 項目すべてであるのに対して **`query`** コマンドでは 1 項目のみであることに注目してください。
### 項目のプライマリキーの値に基づいてテーブルから複数の項目を取得するには
項目のプライマリキーバリューがわかっている場合は、DynamoDB** `batch-get-item` ** コマンドを実行して一致する項目を取得できます。このサンプルで、`CityID` 属性の値が `3`、`Date` 属性の値が `2017-04-13` または `2017-04-14` の項目を取得する方法を説明します。
取得する項目を記述するファイルへのパス (`--request-items`) を指定して、DynamoDB ** `batch-get-item` ** コマンドを実行します。
```
aws dynamodb batch-get-item --request-items file://batch-get-item.json
```
このサンプルでは、`batch-get-item.json` ファイルのコードは、`Weather` テーブルで、`CityID` が `3` であり `Date` が `2017-04-13` または `2017-04-14` である項目を検索するように指定します。検出された各項目について、`City`、`State`、`Date`、および `HighF` (`Temperatures` の一部) の属性値が表示されます (存在する場合)。
```
{
"Weather" : {
"Keys": [
{
"CityID": { "N": "3" },
"Date": { "S": "2017-04-13" }
},
{
"CityID": { "N": "3" },
"Date": { "S": "2017-04-14" }
}
],
"ProjectionExpression": "City, #S, #D, Temperatures.HighF",
"ExpressionAttributeNames": { "#S": "State", "#D": "Date" }
}
}
```
### 一致するすべての項目をテーブルから取得するには
テーブルの属性値について一部でもわかっていることがあれば、DynamoDB** `scan` ** コマンドを実行して一致する項目を取得できます。このサンプルで、`Conditions` 属性の値に `Sunny` が含まれ、`HighF` 属性の値 (`Temperatures` の一部) が `53` より大きい日を取得する方法を説明します。
DynamoDB ** `scan` **コマンドを実行し、以下を指定します。
+ テーブルの名前 (`--table-name`)。
+ 実行する検索 (`--filter-expression`)。
+ 使用する検索基準 (`--expression-attribute-values`)。
+ 一致した項目で表示する属性の種類 (`--select`)。
+ 表示する項目の属性値 (`--projection-expression`)。
+ 属性に DynamoDB の予約済みキーワードが使用されている場合、その属性のエイリアス (`--expression-attribute-names`)。
```
aws dynamodb scan \
--table-name Weather \
--filter-expression \
"(contains (Conditions, :sun)) and (Temperatures.HighF > :h)" \
--expression-attribute-values \
'{ ":sun": { "S" : "Sunny" }, ":h": { "N" : "53" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression "City, #S, #D, Conditions, Temperatures.HighF" \
--expression-attribute-names '{ "#S": "State", "#D": "Date" }'
```
### 一致するすべての項目をグローバルセカンダリインデックスから取得するには
グローバルセカンダリインデックスを使用して検索するには、DynamoDB**`query`** コマンドを使用します。このサンプルで、`weather-global-index` セカンダリインデックスを使用して、日付が `Portland` および `2017-04-13` の、`2017-04-14` という名前の都市の予測天気を取得する方法を説明します。
DynamoDB ** `query` **コマンドを実行し、以下を指定します。
+ テーブルの名前 (`--table-name`)。
+ グローバルセカンダリインデックスの名前 (`--index-name`)。
+ 実行する検索 (`--key-condition-expression`)。
+ 検索で使用する属性値 (`--expression-attribute-values`)。
+ 一致した項目で表示する属性の種類 (`--select`)。
+ 属性に DynamoDB の予約済みキーワードが使用されている場合、その属性のエイリアス (`--expression-attribute-names`)。
```
aws dynamodb query \
--table-name Weather \
--index-name weather-global-index \
--key-condition-expression "(City = :city) and (#D between :date1 and :date2)" \
--expression-attribute-values \
'{ ":city": { "S" : "Portland" }, ":date1": { "S": "2017-04-13" }, ":date2": { "S": "2017-04-14" } }' \
--select SPECIFIC_ATTRIBUTES \
--projection-expression "City, #S, #D, Conditions, Temperatures.HighF" \
--expression-attribute-names '{ "#S": "State", "#D": "Date" }'
```
## ステップ 7: クリーンアップする
このサンプルの使用が完了したら、 AWS アカウントへの継続的な課金を防ぐには、 テーブルを削除する必要があります。テーブルを削除すると、グローバルセカンダリインデックスも削除されます。環境も削除する必要があります。
テーブルを削除するには、テーブルの名前 (**) を指定して DynamoDB`delete-table` ** `--table-name` コマンドを実行します。
```
aws dynamodb delete-table --table-name Weather
```
コマンドが成功した場合は、テーブルに関する情報が表示され、そこで `TableStatus` 値が `DELETING` になっています。
テーブルが正常に削除されたことを確認するには、 DynamoDB** `describe-table` ** コマンドを実行して、テーブルの名前 (`--table-name`) を指定してます。
```
aws dynamodb describe-table --table-name Weather
```
テーブルが正常に削除された場合は、`Requested resource not found` というフレーズを含むメッセージが表示されます。
環境を削除するには、「[環境の削除](delete-environment.md)」を参照してください。
# AWS CDK の チュートリアル AWS Cloud9
このチュートリアルでは、 AWS Cloud Development Kit (AWS CDK) AWS Cloud9 開発環境で を使用する方法を示します。 AWS CDK は、開発者が AWS インフラストラクチャコンポーネントをコードとしてモデル化するために使用できる一連のソフトウェアツールとライブラリです。
AWS CDK には、多くのタスクをすばやく解決するために使用できる AWS コンストラクトライブラリが含まれています AWS。たとえば、`Fleet` コンストラクトを使用すると、コードをホストのフリートに完全かつ安全にデプロイできます。独自のコンストラクトを作成してアーキテクチャのさまざまな要素をモデル化し、これらを他のユーザーと共有したり、コミュニティに公開したりできます。詳細については、「[AWS Cloud Development Kit 開発者ガイド](https://docs.aws.amazon.com/cdk/v2/guide/home.html)」を参照してください。
このチュートリアルに従って、このサンプルを作成すると、 AWS アカウントに料金が発生する可能性があります。これには、Amazon EC2、Amazon SNS、Amazon SQS などのサービスに対して発生する可能性がある料金も含まれます。詳細については、「[Amazon EC2 料金表](https://aws.amazon.com/ec2/pricing/)」、「[Amazon SNS 料金表](https://aws.amazon.com/sns/pricing/)」および「[Amazon SQS 料金表](https://aws.amazon.com/sqs/pricing/)」を参照してください。
**Topics**
+ [前提条件](#sample-cdk-prereqs)
+ [ステップ 1: 必要なツールをインストールする](#sample-cdk-install)
+ [ステップ 2: コードを追加する](#sample-cdk-code)
+ [ステップ 3: コードを実行する](#sample-cdk-run)
+ [ステップ 4: クリーンアップする](#sample-cdk-clean-up)
## 前提条件
このサンプルを使用する前に、設定が次の要件を満たしていることを確認します。
+ **既存の AWS Cloud9 EC2 開発環境が必要です。**このサンプルは、Amazon Linux または Ubuntu Server を実行する Amazon EC2 インスタンスに接続された EC2 環境が既にあることを前提としています。別のタイプの環境またはオペレーティングシステムがある場合、このサンプルの指示を関連ツールを設定する必要がある場合があります。詳細については、「[での環境の作成 AWS Cloud9](create-environment.md)」を参照してください。
+ **既存の環境の AWS Cloud9 IDE が既に開いている。**環境を開くと、 はウェブブラウザでその環境の IDE AWS Cloud9 を開きます。詳細については、「[で環境を開く AWS Cloud9](open-environment.md)」を参照してください。
## ステップ 1: 必要なツールをインストールする
このステップでは、 が TypeScript プログラミング言語で記述されたサンプルを実行する AWS CDK ために必要なすべてのツールを環境にインストールします。
1. [Node Version Manager](#sample-cdk-install-nvm) (**`nvm`**)。後で Node.js をインストールするために使用します。
1. [Node.js](#sample-cdk-install-nodejs)。サンプルで必要であり、Node Package Manager、または TypeScript AWS CDK 以降をインストールするために使用する ** `npm` **が含まれています。
1. [TypeScript](#sample-cdk-install-typescript)。このサンプルに必要です。( では、他のいくつかのプログラミング言語 AWS CDK もサポートされています）。
1. -[AWS CDK](#sample-cdk-install-cdk)。
### ステップ 1.1: Node Version Manager (nvm) をインストールする
1. AWS Cloud9 IDE のターミナルセッションで、最新のセキュリティ更新プログラムとバグ修正がインストールされていることを確認します。これを行うには、** `yum update` ** (Amazon Linux 用)または ** `apt update` ** コマンド (Ubuntu Server 用) を実行します。(新しいターミナルセッションを開始するには、メニューバーで、［**Window (ウィンドウ)**］、［**New Terminal (新しいターミナル)**］の順に選択します。)
Amazon Linux の場合:
```
sudo yum -y update
```
Ubuntu Server の場合:
```
sudo apt update
```
1. ** `nvm` ** がインストール済みであるかどうかを確認します。これを行うには、** `--version` ** オプションを使用して ** `nvm` ** コマンドを実行します。
```
nvm --version
```
成功すると、出力に ** `nvm` ** バージョン番号が表示されます。この場合、「[ステップ 1.2: Node.js をインストールする](#sample-cdk-install-nodejs)」までスキップできます。
1. **`nvm`** をダウンロードしてインストールします。これを行うには、インストールスクリプトを実行します。この例では、v0.33.0 がインストールされていますが、**`nvm`** の最新バージョンは[こちら](https://github.com/nvm-sh/nvm#installing-and-updating)で確認できます。
```
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.0/install.sh | bash
```
1. **`nvm`** の使用を開始します。ターミナルセッションを閉じて再起動するか ** `nvm` ** をロードするコマンドを含む `~/.bashrc` ファイルを入手してください。
```
. ~/.bashrc
```
### ステップ 1.2: Node.js をインストールする
1. Node.js がインストール済みであるかどうかを確認します。インストール済みである場合は、そのバージョンが 16.17.0 以上であることを確認します。**このサンプルは Node.js 16.17.0 を使用してテスト済みです。**IDE でターミナルセッションがまだ開いている状態でチェックするには、** `--version` **オプションと共に ** `node` **コマンドを実行します。
```
node --version
```
Node.js がインストール済みである場合は、出力にバージョン番号が表示されます。バージョン番号が v16.17.0 である場合は、「[ステップ 1.3: TypeScript をインストールする](#sample-cdk-install-typescript)」に進みます。
1. **`nvm`** コマンドを **`install`** アクションと共に実行して、Node.js 16 をインストールします。
**注記**
**`nvm install node`** を実行して、Node.js の長期サポート (LTS) バージョンをインストールすることもできます。 AWS Cloud9 support は、Node.js の LTS バージョンを追跡します。
```
nvm install v16
```
1. Node.js 16 の使用を開始します。これを行うには、**`nvm`** コマンドを実行します。次のように **`alias`** アクション、エイリアスを作成するバージョン番号、このエイリアスで使用するバージョンを指定します。
```
nvm alias default 16
```
**注記**
上のコマンドは、Node.js 16 をデフォルトバージョンの Node.js として設定します。または、** `alias` **アクション (たとえば、** `nvm use 16.17.0` **)の代わりに** `use` **アクションと共に** `nvm` **コマンドとを使用できます。ただし、**`use`** アクションを使用すると、このバージョンの Node.js の実行先は現在実行中のターミナルセッションに限られます。
1. Node.js 16 を使用していることを確認するには、**`node --version`** コマンドを再度実行します。正しいバージョンをインストールしている場合は、出力にバージョン v16 と表示されます。
### ステップ 1.3: TypeScript をインストールする
1. TypeScript がインストール済みであるかどうかを確認します。これを行うには、IDE でターミナルセッションがまだ開いている状態で、** `--version` ** オプションを使ってコマンドライン TypeScript コンパイラーを実行します。
```
tsc --version
```
TypeScript がインストール済みである場合は、出力に TypeScript のバージョン番号が表示されます。TypeScript がインストール済みである場合は、[ステップ 1.4: をインストールする AWS CDK](#sample-cdk-install-cdk) に進みます。
1. TypeScript をインストールします。これを行うには、**`install` **アクション、**`-g` **オプション、および TypeScript パッケージの名前を指定して** `npm` **コマンドを実行します。これにより、TypeScript がグローバルパッケージとして環境 にインストールされます。
```
npm install -g typescript
```
1. TypeScript がインストールされていることを確認します。これを行うには、**`--version`** オプションを使用してコマンドライン TypeScript コンパイラーを実行します。
```
tsc --version
```
TypeScript がインストール済みである場合は、出力に TypeScript のバージョン番号が表示されます。
### ステップ 1.4: をインストールする AWS CDK
1. が既に AWS CDK インストールされているかどうかを確認します。これを行うには、IDE でターミナルセッションがまだ開いている状態で、** `--version` ** オプションを使って、** `cdk` ** コマンドを実行します。
```
cdk --version
```
AWS CDK がインストールされている場合、出力には AWS CDK バージョンとビルド番号が含まれます。[ステップ 2: コードを追加する](#sample-cdk-code) に進んでください。
1. をインストールするには、 ** `npm` ** コマンドを `install`アクション、インストールする AWS CDK パッケージの名前、 環境にパッケージをグローバルにインストールする`-g`オプションとともに AWS CDK 実行します。
```
npm install -g aws-cdk
```
1. がインストールされ、正しく参照 AWS CDK されていることを確認します。これを行うには、** `--version` ** オプションを使用して ** `cdk` ** コマンドを実行します。
```
cdk --version
```
成功すると、 AWS CDK バージョンとビルド番号が表示されます。
## ステップ 2: コードを追加する
このステップでは、 が AWS CloudFormation スタックを AWS CDK プログラムでデプロイするために必要なすべてのソースコードを含むサンプル TypeScript プロジェクトを作成します。このスタックは、 AWS アカウントに Amazon SNS トピックと Amazon SQS キューを作成し、キューをトピックにサブスクライブします。
1. IDE でターミナルセッションがまだ開いている状態で、プロジェクトのソースコードを保存するディレクトリ (例: `~/environment/hello-cdk` ディレクトリ) を環境に作成します。次に、このディレクトリに切り替えます。
```
rm -rf ~/environment/hello-cdk # Remove this directory if it already exists.
mkdir ~/environment/hello-cdk # Create the directory.
cd ~/environment/hello-cdk # Switch to the directory.
```
1. このディレクトリを、 AWS CDKの TypeScript 言語プロジェクトとして設定します。これを行うには、**`init` **アクション、**`sample-app` **テンプレート、**`--language` **オプション、およびプログラミング言語の名前を指定して** `cdk` **コマンドを実行します。
```
cdk init sample-app --language typescript
```
これにより、ディレクトリ内に以下のファイルとサブディレクトリが作成されます。
+ 隠しサブディレクトリ `.git` と隠しファイル `.gitignore`。これにより、プロジェクトは Git などのソース管理ツールと互換性を持ちます。
+ `lib` サブディレクトリ。`hello-cdk-stack.ts` ファイルが含まれます。このファイルには、 AWS CDK スタックのコードが含まれています。このコードは、この手順の次のステップで説明します。
+ `bin` サブディレクトリ。`hello-cdk.ts` ファイルが含まれます。このファイルには、 AWS CDK アプリのエントリポイントが含まれています。
+ `node_modules` サブディレクトリ。必要に応じてアプリケーションとスタックで使用できるサポート用のコードパッケージが含まれます。
+ 隠しファイル `.npmignore`。コードのビルド時に **`npm`** で使用しない種類のサブディレクトリやファイルのリストが含まれます。
+ `cdk.json` ファイル。このファイルの情報を使用すると **`cdk`** コマンドを実行しやすくなります。
+ `package-lock.json` ファイル。このファイルの情報を使用して、**`npm`** はビルドや実行に伴うエラーを減らすことができます。
+ `package.json` ファイル。このファイルの情報を使用すると、**`npm`** コマンドの実行が容易になり、ビルドと実行に伴うエラーも減る可能性があります。
+ ** `npm` ** および で実行できる便利なコマンドを一覧表示する `README.md` ファイル AWS CDK。
+ `tsconfig.json` ファイル。このファイルの情報を使用すると、**`tsc`** コマンドの実行が容易になり、ビルドと実行に伴うエラーも減る可能性があります。
1. [**Environment (環境)**] ウィンドウで、`lib/hello-cdk-stack.ts` ファイルを開き、このファイル内で次のコードを参照します。
```
import sns = require('@aws-cdk/aws-sns');
import sqs = require('@aws-cdk/aws-sqs');
import cdk = require('@aws-cdk/cdk');
export class HelloCdkStack extends cdk.Stack {
constructor(parent: cdk.App, name: string, props?: cdk.StackProps) {
super(parent, name, props);
const queue = new sqs.Queue(this, 'HelloCdkQueue', {
visibilityTimeoutSec: 300
});
const topic = new sns.Topic(this, 'HelloCdkTopic');
topic.subscribeQueue(queue);
}
}
```
+ `Stack`、`App`、`StackProps`、、`Queue`および `Topic` クラスは、 CloudFormation スタックとそのプロパティ、実行可能プログラム、Amazon SQS キュー、および Amazon SNS トピックをそれぞれ表します。
+ `HelloCdkStack` クラスは、このアプリケーションの CloudFormation スタックを表します。このスタックには、このアプリケーションの新しい Amazon SQS キューおよび Amazon SNS トピックが含まれます。
1. [**Environment (環境)**] ウィンドウで、`bin/hello-cdk.ts` ファイルを開き、このファイル内で次のコードを参照します。
```
#!/usr/bin/env node
import cdk = require('@aws-cdk/cdk');
import { HelloCdkStack } from '../lib/hello-cdk-stack';
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack');
app.run();
```
このコードは、`lib/hello-cdk-stack.ts` の `HelloCdkStack` クラスをロードし、インスタンス化して、実行します。
1. ** `npm` ** を使用して TypeScript コンパイラを実行してコーディングエラーを確認し、 を有効に AWS CDK してプロジェクトの `bin/hello-cdk.js` ファイルを実行します。これを行うには、プロジェクトのルートディレクトリから、**`npm` **コマンドを** `run` **アクションで実行します。**`build` **コマンドの値は `package.json` ファイルで次のように指定します。
```
npm run build
```
上のコマンドは、TypeScript コンパイラーを実行します。このコンパイラーは、`bin/hello-cdk.d.ts` ファイルと `lib/hello-cdk-stack.d.ts` ファイルのサポートを追加します。また、このコンパイラーは、`hello-cdk.js` ファイルおよび `hello-cdk-stack.js` ファイルを、`hello-cdk.ts` ファイルおよび `hello-cdk-stack.ts` ファイルとしてトランスパイルします。
## ステップ 3: コードを実行する
このステップでは、 `bin/hello-cdk.js` ファイル内のコードに基づいて CloudFormation スタックテンプレートを作成する AWS CDK ように に指示します。次に、スタックをデプロイ AWS CDK するように に指示します。これにより、Amazon SNS トピックと Amazon SQS キューが作成され、キューがトピックにサブスクライブされます。次に、トピックからキューにメッセージを送信して、トピックとキューが正常にデプロイされていることを確認します。
1. で CloudFormation スタックテンプレート AWS CDK を作成します。これを行うには、 IDE でターミナルセッションがまだ開いている状態で、プロジェクトのルートディレクトリから、** `synth` ** アクションとスタック名を使って、** `cdk` ** コマンドを実行します。
```
cdk synth HelloCdkStack
```
成功すると、出力に CloudFormation スタックテンプレート`Resources`のセクションが表示されます。
1. 特定の AWS アカウントと AWS リージョンの組み合わせの環境に AWS CDK アプリケーションを初めてデプロイする場合は、*ブートストラップスタック*をインストールする必要があります。このスタックには、 がさまざまなオペレーションを完了 AWS CDK するために必要なさまざまなリソースが含まれています。たとえば、このスタックには、デプロイプロセス中に がテンプレートとアセットを保存 AWS CDK するために使用する Amazon S3 バケットが含まれています。ブートストラップスタックをインストールするには、** `cdk` **コマンドを** `bootstrap` ** アクションと共に実行します。
```
cdk bootstrap
```
**注記**
オプションを指定`cdk bootstrap`せずに を実行すると、デフォルトの AWS アカウントと AWS リージョンが使用されます。プロファイルとアカウント/リージョンの組み合わせを指定して、特定の環境をブートストラップすることもできます。例えば、次のようになります。
```
cdk bootstrap --profile test 123456789012/us-east-1
```
1. CloudFormation スタックテンプレート AWS CDK を実行してスタックをデプロイします。これを行うには、プロジェクトのルートディレクトリから、**`cdk`** コマンドに **`deploy`** アクションとスタック名を指定して実行します。
```
cdk deploy HelloCdkStack
```
成功すると、エラーなしでデプロイされた `HelloCdkStack` スタックが出力に表示されます。
**注記**
出力に、スタックが環境を定義しておらず、 AWS 認証情報を標準の場所から取得できなかったか、リージョンが設定されていないというメッセージが表示された場合は、 AWS 認証情報が IDE で正しく設定されていることを確認し、**`cdk deploy`**コマンドを再度実行します。詳細については、「[の環境 AWS のサービス からの呼び出し AWS Cloud9](credentials.md)」を参照してください。
1. Amazon SNS トピックと Amazon SQS キューが正常にデプロイされたことを確認するには、トピックにメッセージを送信し、キューでメッセージが受信されたことをチェックします。これを行うには、 AWS Command Line Interface (AWS CLI) や などのツールを使用できます AWS CloudShell。これらのツールの詳細については、[AWS CLI および の aws-shell チュートリアル AWS Cloud9](sample-aws-cli.md) を参照してください。
たとえば、IDE でターミナルセッションを開いたままトピックにメッセージを送信するには、 AWS CLI を使用して Amazon SNS** `publish` ** コマンドを実行し、メッセージの件名と本文、トピックの AWS リージョン、トピックの Amazon リソースネーム (ARN) を指定します。
```
aws sns publish --subject "Hello from the AWS CDK" --message "This is a message from the AWS CDK." --topic-arn arn:aws:sns:us-east-2:123456789012:HelloCdkStack-HelloCdkTopic1A234567-8BCD9EFGHIJ0K
```
前述のコマンドで、 を トピック CloudFormation に割り当てる ARN `arn:aws:sns:us-east-2:123456789012:HelloCdkStack-HelloCdkTopic1A234567-8BCD9EFGHIJ0K`に置き換えます。この ID を取得するには、Amazon SNS **`list-topics`** コマンドを実行できます。
```
aws sns list-topics --output table --query 'Topics[*].TopicArn'
```
成功すると、**`publish`** コマンドの出力に、発行されたメッセージの `MessageId` 値が表示されます。
キューでメッセージが受信されたことをチェックするには、Amazon SQS **`receive-message`** コマンドを実行して、キューの URL を提供します。
```
aws sqs receive-message --queue-url https://queue.amazonaws.com/123456789012/HelloCdkStack-HelloCdkQueue1A234567-8BCD9EFGHIJ0K
```
前述のコマンドで、 をキュー CloudFormation に割り当てる ARN `https://queue.amazonaws.com/123456789012/HelloCdkStack-HelloCdkQueue1A234567-8BCD9EFGHIJ0K`に置き換えます。この URL を取得するため、 Amazon SQS **`list-queues`** コマンドを実行できます。
```
aws sqs list-queues --output table --query 'QueueUrls[*]'
```
成功すると、**`receive-message`** コマンドの出力に、受信されたメッセージの情報が表示されます。
## ステップ 4: クリーンアップする
このサンプルの使用が完了したら、 AWS アカウントへの継続的な課金を防ぐには、 CloudFormation スタックを削除する必要があります。これにより、Amazon SNS トピックと Amazon SQS キューが削除されます。環境も削除する必要があります。
### ステップ 4.1: スタックを削除する
IDE でターミナルセッションがまだ開いている状態で、プロジェクトのルートディレクトリから、 ** `destroy` ** アクションとスタック名で ** `cdk` ** コマンドを実行します。
```
cdk destroy HelloCdkStack
```
スタックの削除を確認するメッセージが表示されたら、「`y`」と入力し、`Enter` キーを押します。
成功すると、エラーなしで `HelloCdkStack` スタックが削除されたことが出力に表示されます。
### ステップ 4.2: 環境を削除する
環境を削除するには、[での環境の削除 AWS Cloud9](delete-environment.md) を参照してください。
# の LAMP チュートリアル AWS Cloud9
このチュートリアルでは、 AWS Cloud9 開発環境内で LAMP (Linux、Apache HTTP Server、MySQL、および PHP) をセットアップして実行できます。
このチュートリアルに従い、このサンプルを作成すると、 に料金が発生する可能性があります AWS アカウント。これには、Amazon Elastic Compute Cloud (Amazon EC2) AWS のサービス などの の料金が含まれます。詳細については、「[Amazon EC2 の料金](https://aws.amazon.com/ec2/pricing/)」を参照してください。
**Topics**
+ [前提条件](#sample-lamp-prereqs)
+ [ステップ 1: ツールのインストール](#sample-lamp-install-tools)
+ [ステップ 2: MySQL を設定する](#sample-lamp-setup-mysql)
+ [ステップ 3: ウェブサイトの設定](#sample-lamp-apache)
+ [ステップ 4: クリーンアップする](#sample-lamp-clean-up)
## 前提条件
このサンプルを使用する前に、設定が次の要件を満たしていることを確認します。
+ **既存の AWS Cloud9 EC2 開発環境が必要です。**このサンプルは、Amazon Linux または Ubuntu Server を実行する Amazon EC2 インスタンスに接続された EC2 環境が既にあることを前提としています。別のタイプの環境またはオペレーティングシステムがある場合、このサンプルの指示を関連ツールを設定する必要がある場合があります。詳細については、「[での環境の作成 AWS Cloud9](create-environment.md)」を参照してください。
+ **既存の環境の AWS Cloud9 IDE が既に開いている。**環境を開くと、 はウェブブラウザでその環境の IDE AWS Cloud9 を開きます。詳細については、「[で環境を開く AWS Cloud9](open-environment.md)」を参照してください。
## ステップ 1: ツールのインストール
このステップでは、以下のツールをインストールします。
+ Apache HTTP Server: ウェブサーバーホスト。
+ PHP: 特にウェブ開発に適しており、HTML に埋め込むことができるスクリプト言語。
+ MySQL: データベース管理システム。
その後、このステップを終了するには、Apache HTTP サーバーを起動後、MySQL を起動します。
1. インスタンスに最新のセキュリティ更新プログラムとバグ修正が適用されていることを確認します。これを行うには、IDE AWS Cloud9 のターミナルセッションで、 **`yum update`** for (Amazon Linux) または **`apt update`** for (Ubuntu Server) コマンドを実行します。(新しいターミナルセッションを開始するには、メニューバーで、［**Window (ウィンドウ)**］、［**New Terminal (新しいターミナル)**］の順に選択します。)
Amazon Linux の場合:
```
sudo yum -y update
```
Ubuntu サーバーの場合:
```
sudo apt -y update
```
1. Apache HTTP Server が既にインストールされているかどうかを確認します。これを行うには、**`httpd -v`** (Amazon Linux)または **`apache2 -v`** (Ubuntu Server) コマンドを実行します。
成功すると、Apache HTTP Server のバージョン番号が出力に表示されます。
エラーが発生する場合は、**`install`** コマンドを実行して Apache HTTP Server をインストールします。
Amazon Linux の場合:
```
sudo yum install -y httpd24
```
Ubuntu サーバーの場合:
```
sudo apt install -y apache2
```
1. **`php -v`** コマンドを実行して PHP が既にインストールされているかどうかを確認します。
成功すると、出力に PHP のバージョン番号が表示されます。
エラーが発生する場合は、**`install`** コマンドを実行して PHP をインストールします。
Amazon Linux の場合:
```
sudo yum install -y php56
```
Ubuntu サーバーの場合:
```
sudo apt install -y php libapache2-mod-php php-xml
```
1. **`mysql --version`** コマンドを実行して MySQL が既にインストールされているかどうかを確認します。
成功すると、出力に MySQL のバージョン番号が表示されます。
エラーが発生する場合は、**`install`** コマンドを実行して MySQL をインストールします。
Amazon Linux の場合:
```
sudo yum install -y mysql-server
```
Ubuntu サーバーの場合:
```
sudo apt install -y mysql-server
```
1. Apache HTTP Server、PHP、および MySQL をインストールしたら、Apache HTTP Server を起動後、次のコマンドを実行して、起動したことを確認します。
Amazon Linux の場合 (このコマンドを 2 回実行する必要がある場合があります):
```
sudo service httpd start && sudo service httpd status
```
Ubuntu Server の場合 (コマンドプロンプトに戻るには、`q` を押します):
```
sudo service apache2 start && sudo service apache2 status
```
1. MySQL を起動後、次のコマンドを実行して、起動したことを確認します。
Amazon Linux の場合:
```
sudo service mysqld start && sudo service mysqld status
```
Ubuntu Server の場合 (コマンドプロンプトに戻るには、`q` を押します):
```
sudo service mysql start && sudo service mysql status
```
## ステップ 2: MySQL を設定する
このステップでは、MySQL セキュリティのベストプラクティスに従うようにMySQL を設定します。これらのセキュリティのベストプラクティスには、ルートアカウントのパスワードの設定や、ローカルホストの外部からアクセス可能なルートアカウントの削除が含まれます。他に注意すべきベストプラクティスとしては、匿名ユーザーの削除、テスト用データベースの削除、`test_` で始まる名前のデータベースに誰でもアクセスできる権限の削除があります。
その後、MySQL コマンドラインクライアントの起動と終了を行い、このステップを終了します。
1. MySQL をインストールするための MySQL セキュリティのベストプラクティスを実装するには、 AWS Cloud9 IDE のターミナルセッションで次のコマンドを実行します。
```
sudo mysql_secure_installation
```
1. プロンプトが表示されたら、指定されたとおりに次の質問に回答します。
Amazon Linux の場合:
1. **root の現在のパスワードを入力 (ない場合は Enter キー)** – `Enter`を押してください (パスワードがない場合)。
1. **root のパスワードの設定** – `Y` と入力し、`Enter` を押してください。
1. **新しいパスワード** – パスワードを入力し、`Enter` を押してください。
1. **新しいパスワードの再入力** – パスワードを再入力し、`Enter` を押してください。(後に使用できるように、パスワードは安全な場所に保存してください。)
1. **匿名ユーザーの削除** – `Y` と入力し、`Enter` を押してください。
1. **root のリモートログインを禁止** – `Y` と入力し、`Enter` を押してください。
1. **テストデータベースを削除し、アクセスする** – `Y` と入力し、`Enter` を押してください。
1. **権限テーブルを再ロード** – `Y` と入力し、`Enter` を押してください。
Ubuntu サーバーの場合:
1. **パスワード検証プラグインのセットアップ** – `y` と入力し、`Enter` を押します。
1. **パスワード検証ポリシーには 3 つのレベルがあります** – `0`、`1`、または `2` と入力し、`Enter` を押します。
1. **新しいパスワード** – パスワードを入力し、`Enter` を押します。
1. **新しいパスワードの再入力** – パスワードを再入力し、`Enter` を押します。後に使用できるように、パスワードは安全な場所に保存してください。
1. **提供されたパスワードを続行しますか?** – `y` と入力し、`Enter` を押します。
1. **匿名ユーザーの削除** – `y` と入力し、`Enter` を押します。
1. **ルートのリモートログインを禁止** – `y` と入力し、`Enter` を押します。
1. **テストデータベースを削除し、アクセスする** – `y` と入力し、`Enter` を押します。
1. **権限テーブルを再ロード** – `y` と入力し、`Enter` を押します。
1. MySQL を直接操作するには、次のコマンドを実行して、ルートユーザーとして MySQL コマンドラインクライアントをスタートします。プロンプトが表示されたら、先ほど設定した root ユーザーのパスワードを入力し、`Enter` を押します。MySQL コマンドラインクライアントを使用している場合、プロンプトは `mysql>` に変更されます。
```
sudo mysql -uroot -p
```
1. MySQL コマンドラインクライアントを終了するには、次のコマンドを実行します。プロンプトは `$` に戻ります。
```
exit;
```
## ステップ 3: ウェブサイトの設定
このステップでは、Apache HTTP Server のデフォルトウェブサイトのルートに、推奨される所有者とアクセス許可を設定します。その後、そのデフォルトウェブサイトのルート内に PHP ベースのウェブページを作成します。
次に、この EC2環境に関連付けられている Amazon Virtual Private Cloud (Amazon VPC) にあるAmazon EC2 のセキュリティグループと Amazon EC2 とネットワークのアクセスコントロールリスト (ACL) を設定して、着信ウェブトラフィックでそのウェブページの表示を有効にします。各 EC2 環境は、Amazon EC2 のセキュリティグループと Amazon VPC のネットワーク ACL の両方に関連付ける必要があります。ただし、 AWS アカウント のデフォルトネットワーク ACL では環境のすべての送受信トラフィックが許可されていますが、デフォルトのセキュリティグループでは、ポート 22 経由で SSH を使用した着信トラフィックのみが許可されています。詳細については、「[AWS Cloud9 開発環境の VPC 設定](vpc-settings.md)」を参照してください。
その後、 AWS Cloud9 IDE の外部からウェブページを正常に表示して、このステップを終了します。
1. Apache HTTP Server のデフォルトウェブサイトのルート (`/var/www/html`) に、推奨される所有者とアクセス許可を設定します。これを行うには、IDE のターミナルセッションで、次の 6 つのコマンドを一度に 1 AWS Cloud9 つずつ次の順序で実行します。各コマンドの動作を理解するには、各コマンドの後の `#` の情報をお読みください。
Amazon Linux の場合:
```
sudo groupadd web-content # Create a group named web-content.
sudo usermod -G web-content -a ec2-user # Add the user ec2-user (your default user for this environment) to the group web-content.
sudo usermod -G web-content -a apache # Add the user apache (Apache HTTP Server) to the group web-content.
sudo chown -R ec2-user:web-content /var/www/html # Change the owner of /var/www/html and its files to user ec2-user and group web-content.
sudo find /var/www/html -type f -exec chmod u=rw,g=rx,o=rx {} \; # Change all file permissions within /var/www/html to user read/write, group read-only, and others read/execute.
sudo find /var/www/html -type d -exec chmod u=rwx,g=rx,o=rx {} \; # Change /var/www/html directory permissions to user read/write/execute, group read/execute, and others read/execute.
```
Ubuntu サーバーの場合:
```
sudo groupadd web-content # Create a group named web-content.
sudo usermod -G web-content -a ubuntu # Add the user ubuntu (your default user for this environment) to the group web-content.
sudo usermod -G web-content -a www-data # Add the user www-data (Apache HTTP Server) to the group web-content.
sudo chown -R ubuntu:web-content /var/www/html # Change the owner of /var/www/html and its files to user ubuntu and group web-content.
sudo find /var/www/html -type f -exec chmod u=rw,g=rx,o=rx {} \; # Change all file permissions within /var/www/html to user read/write, group read-only, and others read/execute.
sudo find /var/www/html -type d -exec chmod u=rwx,g=rx,o=rx {} \; # Change /var/www/html directory permissions to user read/write/execute, group read/execute, and others read/execute.
```
1. 次のコマンドを実行して、`index.php` という PHP ベースのウェブページを Apache HTTP Server のデフォルトウェブサイトルートフォルダ (`/var/www/html`) に作成します。
Amazon Linux の場合:
```
sudo touch /var/www/html/index.php && sudo chown -R ec2-user:web-content /var/www/html/index.php && sudo chmod u=rw,g=rx,o=rx /var/www/html/index.php && sudo printf '%s\n%s\n%s' '' >> /var/www/html/index.php
```
Amazon Linux の場合も、上記コマンドによって、ファイルの所有者は `ec2-user` に、ファイルのグループは `web-content` に、ファイルのアクセス許可は、読み取り/書き込み (ユーザー)、読み取り/実行 (グループ、その他) に変更されます。
Ubuntu サーバーの場合:
```
sudo touch /var/www/html/index.php && sudo chown -R ubuntu:web-content /var/www/html/index.php && sudo chmod u=rw,g=rx,o=rx /var/www/html/index.php && sudo printf '%s\n%s\n%s' '' >> /var/www/html/index.php
```
Ubuntu Server の場合も、上記コマンドによって、ファイルの所有者は `ubuntu` に、ファイルのグループは `web-content` に、ファイルのアクセス許可は、読み書き (ユーザー)、読み取り/実行 (グループ、その他) に変更されます。
上記コマンドが正常に実行されると、次の内容で `index.php` ファイルが作成されます。
```
```
1. Amazon VPC のネットワーク ACL と、この EC2 環境に関連付けられている Amazon EC2 のセキュリティグループを設定して、ポート 80 経由の着信ウェブトラフィックで新しいウェブページを表示を有効にします。そのためには、次の 8 個のコマンドを一度に 1 つずつ次の順序で実行します。各コマンドの動作を理解するには、各コマンドの `#` の後に表示される情報をお読みください。
**重要**
次のコマンドを実行すると、この環境のセキュリティグループとネットワーク ACL に関連付けられている**すべて**の EC2 環境と Amazon EC2 インスタンスに対するポート 80 経由の着信ウェブトラフィックを有効にします。これにより、これ以外の EC2 環境および Amazon EC2 インスタンスに対して、ポート 80 経由の着信ウェブトラフィックが予期せずに有効になる可能性があります。
**注記**
次の 2 番目から 4 番目のコマンドでは、セキュリティグループのポート 80 経由の着信ウェブトラフィックが有効になります。ポート 22 経由の着信 SSH トラフィックのみを許可するデフォルトのセキュリティグループがある場合は、最初のコマンドとそれに続く 2 番目から 4 番目のコマンドを実行する必要があります。ただし、カスタムセキュリティグループで、既にポート 80 経由の着信ウェブトラフィックが許可されている場合は、これらのコマンドの実行をスキップすることができます。
次の 5 番目から 8 番目のコマンドでは、ネットワーク ACL のポート 80 経由の着信ウェブトラフィックの許可が有効になります。デフォルトのネットワーク ACL があり、すべてのポート経由ですべての着信トラフィックがすでに許可されている場合は、これらのコマンドの実行をスキップすることができます。ただし、ポート 80 経由の着信ウェブトラフィックを許可しないカスタムネットワーク ACL を保有しているとします。その場合、最初のコマンドを実行してから、5 番目から 8 番目のコマンドを実行します。
```
MY_INSTANCE_ID=$(curl http://169.254.169.254/latest/meta-data/instance-id) # Get the ID of the instance for the environment, and store it temporarily.
MY_SECURITY_GROUP_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SecurityGroups[0].GroupId' --output text) # Get the ID of the security group associated with the instance, and store it temporarily.
aws ec2 authorize-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --protocol tcp --cidr 0.0.0.0/0 --port 80 # Add an inbound rule to the security group to allow all incoming IPv4-based traffic over port 80.
aws ec2 authorize-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --ip-permissions IpProtocol=tcp,Ipv6Ranges='[{CidrIpv6=::/0}]',FromPort=80,ToPort=80 # Add an inbound rule to the security group to allow all incoming IPv6-based traffic over port 80.
MY_SUBNET_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SubnetId' --output text) # Get the ID of the subnet associated with the instance, and store it temporarily.
MY_NETWORK_ACL_ID=$(aws ec2 describe-network-acls --filters Name=association.subnet-id,Values=$MY_SUBNET_ID --query 'NetworkAcls[].Associations[0].NetworkAclId' --output text) # Get the ID of the network ACL associated with the subnet, and store it temporarily.
aws ec2 create-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --protocol tcp --rule-action allow --rule-number 10000 --cidr-block 0.0.0.0/0 --port-range From=80,To=80 # Add an inbound rule to the network ACL to allow all IPv4-based traffic over port 80. Advanced users: change this suggested rule number as desired.
aws ec2 create-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --protocol tcp --rule-action allow --rule-number 10100 --ipv6-cidr-block ::/0 --port-range From=80,To=80 # Add an inbound rule to the network ACL to allow all IPv6-based traffic over port 80. Advanced users: change this suggested rule number as desired.
```
1. ウェブサーバーのルート内にある `index.php` ファイルへの URL を取得します。これを行うには、次のコマンドを実行し、新しいウェブブラウザタブまたは AWS Cloud9 IDE とは別のウェブブラウザを使用して、表示される URL に移動します。正常に実行された場合は、Apache HTTP Server、MySQL、PHP、およびその他の関連設定に関する情報がウェブページに表示されます。
```
MY_PUBLIC_IP=$(curl http://169.254.169.254/latest/meta-data/public-ipv4) && echo http://$MY_PUBLIC_IP/index.php # Get the URL to the index.php file within the web server root.
```
## ステップ 4: クリーンアップする
この環境を引き続き使用するものの、ポート 80 経由の着信ウェブトラフィックを無効にしたいとします。その場合、次の 8 個のコマンドを 1 度にひとつずつ次の順序で実行し、環境に関連付けられているセキュリティグループおよびネットワーク ACL で先ほど設定した該当の着信トラフィックルールを削除します。各コマンドの動作を理解するには、各コマンドの `#` の後に表示される情報をお読みください。
**重要**
次のコマンドを実行すると、この環境のセキュリティグループとネットワーク ACL に関連付けられている**すべて**の EC2 環境と Amazon EC2 インスタンスに対して、ポート 80 経由の着信 ウェブトラフィックが無効になります。これにより、これ以外の EC2 環境および Amazon EC2 インスタンスに対して、ポート 80 経由の着信ウェブトラフィックが予期せずに無効になる可能性があります。
**注記**
次の 5 番目から 8 番目のコマンドでは、既存のルールを削除して、ネットワーク ACL でポート 80 経由の着信ウェブトラフィックが許可されないようにします。デフォルトのネットワーク ACL があり、すべてのポート経由ですべての着信トラフィックがすでに許可されている場合は、これらのコマンドの実行をスキップすることができます。ただし、ポート 80 経由の着信ウェブトラフィックを許可する既存のルールを含むカスタムネットワーク ACL があり、それらのルールを削除したいとします。その場合、最初のコマンドとそれに続く 5 番目から 8 番目のコマンドを実行する必要があります。
```
MY_INSTANCE_ID=$(curl http://169.254.169.254/latest/meta-data/instance-id) # Get the ID of the instance for the environment, and store it temporarily.
MY_SECURITY_GROUP_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SecurityGroups[0].GroupId' --output text) # Get the ID of the security group associated with the instance, and store it temporarily.
aws ec2 revoke-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --protocol tcp --cidr 0.0.0.0/0 --port 80 # Delete the existing inbound rule from the security group to block all incoming IPv4-based traffic over port 80.
aws ec2 revoke-security-group-ingress --group-id $MY_SECURITY_GROUP_ID --ip-permissions IpProtocol=tcp,Ipv6Ranges='[{CidrIpv6=::/0}]',FromPort=80,ToPort=80 # Delete the existing inbound rule from the security group to block all incoming IPv6-based traffic over port 80.
MY_SUBNET_ID=$(aws ec2 describe-instances --instance-id $MY_INSTANCE_ID --query 'Reservations[].Instances[0].SubnetId' --output text) # Get the ID of the subnet associated with the instance, and store it temporarily.
MY_NETWORK_ACL_ID=$(aws ec2 describe-network-acls --filters Name=association.subnet-id,Values=$MY_SUBNET_ID --query 'NetworkAcls[].Associations[0].NetworkAclId' --output text) # Get the ID of the network ACL associated with the subnet, and store it temporarily.
aws ec2 delete-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --rule-number 10000 # Delete the existing inbound rule from the network ACL to block all IPv4-based traffic over port 80. Advanced users: if you originally created this rule with a different number, change this suggested rule number to match.
aws ec2 delete-network-acl-entry --network-acl-id $MY_NETWORK_ACL_ID --ingress --rule-number 10100 # Delete the existing inbound rule from the network ACL to block all IPv6-based traffic over port 80. Advanced users: if you originally created this rule with a different number, change this suggested rule number to match.
```
この環境を使用し終わったら、今後、 AWS アカウントに料金が請求されないように、その環境を削除します。手順については、[での環境の削除 AWS Cloud9](delete-environment.md) を参照してください。
# の WordPress チュートリアル AWS Cloud9
このチュートリアルでは、 AWS Cloud9 開発環境内で WordPress をインストールして実行できます。WordPress は、配信ウェブコンテンツに広く使用されているオープンソースのコンテンツ管理システム (CMS) です。
**注記**
このチュートリアルに従い、このサンプルを作成すると、 AWS アカウントに料金が発生する可能性があります。これには、Amazon Elastic Compute Cloud (Amazon EC2) などのサービスに対して発生する可能性のある料金が含まれます。詳細については、「[Amazon EC2 の料金](https://aws.amazon.com/ec2/pricing/)」を参照してください。
## 前提条件
このサンプルを使用する前に、設定が次の要件を満たしていることを確認します。
+ **既存の AWS Cloud9 EC2 開発環境が必要です。**このサンプルは、Amazon Linux または Ubuntu Server を実行する Amazon EC2 インスタンスに接続された EC2 環境が既にあることを前提としています。別のタイプの環境またはオペレーティングシステムがある場合、このサンプルの指示を関連ツールを設定する必要がある場合があります。詳細については、「[での環境の作成 AWS Cloud9](create-environment.md)」を参照してください。
+ **既存の環境の AWS Cloud9 IDE が既に開いている。**環境を開くと、 はウェブブラウザでその環境の IDE AWS Cloud9 を開きます。詳細については、「[で環境を開く AWS Cloud9](open-environment.md)」を参照してください。
+ **すべての最新ソフトウェアパッケージを含む最新の EC2 インスタンスを持っています**。 AWS Cloud9 IDE ターミナルウィンドウで、 オプション`yum update`を使用して を実行し、確認を求めることなく更新`-y`をインストールできます。インストール前に更新を検査する場合は、このオプションを省略できます。
```
sudo yum update -y
```
## インストールの概要
環境の EC2 インスタンスに WordPress をインストールするには、以下のステップを実行:
1. WordPress インストールに関する情報を格納するオープンソースのリレーショナルデータベースである MariaDB サーバーのインストールと設定
1. WordPress のインストールと設定。これには、`wordpress.conf` 設定ファイルの編集が含まれます。
1. WordPress サイトをホストする Apache サーバーの設定
1. Apache サーバーによってホストされている WordPress ウェブコンテンツのプレビュー
## ステップ 1: MariaDB サーバーのインストールと設定
1. AWS Cloud9 IDE で、**ウィンドウ**、**新しいターミナル**を選択し、次のコマンドを入力して MariaDB サーバーのインストールをインストールして開始します。
```
sudo yum install -y mariadb-server
sudo systemctl start mariadb
```
1. 次に、`mysql_secure_installation` スクリプトを実行して、MariaDB サーバーのインストールのセキュリティを向上させることができます。
スクリプトへの応答を指定するときは、最初の質問に対して、［**入力**］を押して、root パスワードを空白のままにします。`Set root password?` に対して**n**を押し、残りの各セキュリティオプションに対しては**y**を押します。
```
mysql_secure_installation
```
1. 今、MariaDB クライアントを使用して WordPress 情報を保存するためデータベーステーブルを作成します。
(パスワードを求められた場合、**入力**を押します。)
```
sudo mysql -u root -p
MariaDB [(none)]> create database wp_test;
MariaDB [(none)]> grant all privileges on wp_test.* to root@localhost identified by ';'
```
1. MariaDB クライアントからログアウトするには、`exit` コマンドを実行します。
## ステップ 2: WordPress のインストールと設定
1. IDE ターミナルウィンドウで、`environment`ディレクトリに移動して、ディレクトリ `config` および `wordpress` を作成します。次に、`touch` コマンドを実行して、`config` ディレクトリで `wordpress.conf` という名前のファイルを作成:
```
cd /home/ec2-user/environment
mkdir config wordpress
touch config/wordpress.conf
```
1. IDE エディタまたは vim を使用して、`wordpress.conf`を更新して、Apache サーバーによる WordPress コンテンツの提供を許可するホスト構成情報に置き換え:
```
# Ensure that Apache listens on port 80
Listen 8080
DocumentRoot "/var/www/wordpress"
ServerName www.example.org
# Other directives here
```
1. 次に、次のコマンドを実行して必要なアーカイブファイルを取得し、WordPress をインストール:
```
cd /home/ec2-user/environment
wget https://wordpress.org/latest.tar.gz
tar xvf latest.tar.gz
```
1. `touch` コマンドを実行して、`environment/wordpress` ディレクトリで `wp-config.php` という名前のファイルを作成:
```
touch wordpress/wp-config.php
```
1. IDE エディタまたは vim を使用して `wp-config.php` を更新します。次に、サンプルデータを自分の設定に置き換えます。
```
// ** MySQL settings - You can get this info from your web host ** //
/** The name of the database for WordPress */
define( 'DB_NAME', 'wp_test' );
/** MySQL database username */
define( 'DB_USER', 'wp_user' );
/** MySQL database password */
define( 'DB_PASSWORD', 'YourSecurePassword' );
/** MySQL hostname */
define( 'DB_HOST', 'localhost' );
/** Database Charset to use in creating database tables. */
define( 'DB_CHARSET', 'utf8' );
/** The Database Collate type. Don't change this if in doubt. */
define( 'DB_COLLATE', '' );
define('FORCE_SSL', true);
if ($_SERVER['HTTP_X_FORWARDED_PROTO'] == 'https') $_SERVER['HTTPS'] = 'on';
```
## ステップ 3: Apache HTTP サーバーの設定
1. AWS Cloud9 IDE ターミナルウィンドウで、Apache がインストールされていることを確認します。
```
httpd -v
```
Apache サーバー がインストールされていないのであれば、次のコマンドを実行:
```
sudo yum install -y httpd
```
1. `/etc/httpd/conf.d` ディレクトリに移動します。このディレクトリは Apache の仮想ホスト設定ファイルの場所です。次に、`ln` コマンドを実行して、以前に作成した `wordpress.conf` を現在の作業ディレクトリ (`/etc/httpd/conf.d`)にリンク:
```
cd /etc/httpd/conf.d
sudo ln -s /home/ec2-user/environment/config/wordpress.conf
```
1. さて、`/var/www` ディレクトリに移動します。ここは Apache サーバーのデフォルトのルートフォルダです。そして、`ln` コマンドを実行して、先ほど作成した `wordpress` ディレクトリを、現在の作業ディレクトリ (`/var/www`)とリンク:
```
cd /var/www
sudo ln -s /home/ec2-user/environment/wordpress
```
1. `chmod` コマンドを実行して、Apache サーバーによる `wordpress` サブディレクトリでのコンテンツ実行を許可:
```
sudo chmod +x /home/ec2-user/
```
1. Apache サーバーを再起動して、新しい設定の検出を許可:
```
sudo service httpd restart
```
## ステップ 4: WordPress ウェブコンテンツのプレビュー
1. AWS Cloud9 IDE を使用して、 ディレクトリ`index.html`に という名前の新しいファイルを作成します`environment/wordpress`。
1. HTML 形式のテキストを `index.html` に追加します。例えば、次のようになります。
```
Hello World!
```
1. **[環境]**ウィンドウで、`index.html` ファイルを選択してから、**[プレビュー]**、**[実行中のアプリケーションのプレビュー]** の順に選択します。
*Hello World\$1*メッセージを表示しているウェブページは、アプリケーションのプレビュータブに表示されます。ご希望のブラウザーでウェブコンテンツを表示するには、**Pop Out Into New Window (新しいウィンドウで開く)**を選択してください。
`index.html` ファイルを削除し、アプリケーションのプレビュータブを更新すると、WordPress の設定ページが表示されます。
## 混在コンテンツのエラーを管理する
ウェブブラウザは、HTTPS スクリプトと HTTP スクリプトまたはコンテンツを同時にロードしている場合、WordPress サイトの混在コンテンツエラーを表示します。エラーメッセージの文言は、使用しているウェブブラウザーによって異なりますが、サイトへの接続が安全でないか、完全に安全でないことが通知されます。また、ウェブブラウザは、混在コンテンツへのアクセスをブロックします。
**重要**
デフォルトで、 AWS Cloud9 IDE アプリケーションのプレビュータブでアクセスするすべての ウェブページは自動的に HTTPS プロトコルを使用します。ページの URI が安全でない `http` プロトコルをとりあげている場合、`https` によって自動的に置き換えられます。また、手動で `https` を `http` に変更しても、安全でないコンテンツにアクセスすることはできません。
ウェブサイトに HTTPS 実装に関するガイダンスについては、[WordPress のドキュメント](https://wordpress.org/support/article/https-for-wordpress/)を参照してください。
# の Java チュートリアル AWS Cloud9
**重要**
2 GiB 以上のメモリを持つ EC2 インスタンスにバックアップされた AWS Cloud9 開発環境を使用している場合は、拡張 Java サポートを有効にすることをお勧めします。有効にすると、コード補完、エラーの linting、コンテキスト固有のアクション、ブレークポイントやステッピングなどのデバッグオプションを含む生産性向上機能が使用できます。
詳細については、「[Java 開発のサポートの強化](enhanced-java.md)」を参照してください。
このチュートリアルでは、 AWS Cloud9 開発環境でいくつかの Java コードを実行できます。
このチュートリアルに従って、このサンプルを作成すると、 AWS アカウントに料金が発生する可能性があります。Amazon EC2 や Amazon S3 などのサービスに対して発生する可能性がある料金も含まれます。詳細については、「[Amazon EC2 料金表](https://aws.amazon.com/ec2/pricing/)」および「[Amazon S3 料金表](https://aws.amazon.com/s3/pricing/)」を参照してください。
**Topics**
+ [前提条件](#sample-java-prerequisites)
+ [ステップ 1: 必要なツールをインストールする](#sample-java-install)
+ [ステップ 2: コードを追加する](#sample-java-code)
+ [ステップ 3: コードを構築して実行する](#sample-java-run)
+ [ステップ 4: を使用するように を設定する AWS SDK for Java](#sample-java-sdk)
+ [ステップ 5: 環境で AWS 認証情報管理を設定する](#sample-java-sdk-creds)
+ [ステップ 6: AWS SDK コードを追加する](#sample-java-sdk-code)
+ [ステップ 7: AWS SDK コードを構築して実行する](#sample-java-sdk-run)
+ [ステップ 8: クリーンアップする](#sample-java-clean-up)
## 前提条件
このサンプルを使用する前に、設定が次の要件を満たしていることを確認します。
+ **既存の AWS Cloud9 EC2 開発環境が必要です。**このサンプルは、Amazon Linux または Ubuntu Server を実行する Amazon EC2 インスタンスに接続された EC2 環境が既にあることを前提としています。別のタイプの環境またはオペレーティングシステムがある場合、このサンプルの指示を関連ツールを設定する必要がある場合があります。詳細については、「[での環境の作成 AWS Cloud9](create-environment.md)」を参照してください。
+ **既存の環境の AWS Cloud9 IDE が既に開いている。**環境を開くと、 はウェブブラウザでその環境の IDE AWS Cloud9 を開きます。詳細については、「[で環境を開く AWS Cloud9](open-environment.md)」を参照してください。
## ステップ 1: 必要なツールをインストールする
このステップでは、一連の Java 開発ツール AWS Cloud9 を開発環境にインストールします。Oracle JDK や OpenJDK などの Java 開発ツールのセットが環境にインストール済みである場合は、[ステップ 2: コードを追加する](#sample-java-code) に進むことができます。このサンプルは、OpenJDK 8 で開発されました。次の手順を実行して、環境にインストールすることができます。
1. OpenJDK 8 が既にインストールされているかどうかを確認します。これを行うには、IDE AWS Cloud9 のターミナルセッションで、 **`-version`**オプションを使用して Java ランナーのコマンドラインバージョンを実行します。(新しいターミナルセッションを開始するには、メニューバーで、［**Window (ウィンドウ)**］、［**New Terminal (新しいターミナル)**］の順に選択します。)
```
java -version
```
上記のコマンドの出力に基づいて、次のいずれかの操作を行います。
+ `java` コマンドが見つからないことを出力が示している場合は、この手順のステップ 2 に進み、OpenJDK 8 をインストールします。
+ 出力に `Java(TM)`、`Java Runtime Environment`、`Java SE`、`J2SE`、または `Java2` から始まる値が含まれている場合、OpenJDK がインストールされていないか、デフォルト Java 開発ツールセットとして設定されていません。この手順のステップ 2 に進んで OpenJDK 8 をインストールし、OpenJDK 8 の使用に切り替えます。
+ 出力に `java version 1.8` および `OpenJDK` で始まる値がある場合は、[ステップ 2: コードを追加する](#sample-java-code) に進みます。このサンプルの OpenJDK 8 が正しくインストールされます。
+ 出力に `java version` 未満の `1.8` と `OpenJDK` で始まる値が含まれている場合、この手順のステップ 2 に進んで、インストールされた OpenJDK バージョンを OpenJDK 8 にアップグレードします。
1. 最新のセキュリティ更新およびバグ修正がインストールされていることを確認します。これを行うには、yum ツール (Amazon Linux の場合) または apt ツール (Ubuntu Server の場合) を** `update` **コマンドを実行します。
Amazon Linux の場合:
```
sudo yum -y update
```
Ubuntu Server の場合:
```
sudo apt update
```
1. OpenJDK 8 をインストールします。これを行うには、yum ツール (Amazon Linux の場合) または apt ツール (Ubuntu Server の場合) を** `install` **コマンドを使用して OpenJDK 8 パッケージを実行します。
Amazon Linux の場合:
```
sudo yum -y install java-1.8.0-openjdk-devel
```
Ubuntu Server の場合:
```
sudo apt install -y openjdk-8-jdk
```
詳細については、OpenJDK ウェブサイトで「[How to download and install prebuilt OpenJDK packages](https://openjdk.org/install/)」を参照してください。
1. デフォルトの Java 開発ツールセットを OpenJDK 8 に切り替えるかアップグレードします。これを行うには、** `--config` ** オプションを使用して ** `update-alternatives` ** コマンドを実行します。このコマンドを 2 回実行し、Java ランナーおよびコンパイラのコマンドラインバージョンに切り替えるかアップグレードします。
```
sudo update-alternatives --config java
sudo update-alternatives --config javac
```
各プロンプトで、OpenJDK 8 の選択番号を入力します (`java-1.8` を含む番号)。
1. Java ランナーおよびコンパイラのコマンドラインバージョンが OpenJDK 8 を使用していることを確認します。これを行うには、`-version` オプションを使用して Java ランナーおよびコンパイラのコマンドラインバージョンを実行します。
```
java -version
javac -version
```
OpenJDK 8 が適切にインストールされて設定されている場合、Java ランナーバージョンの出力には `openjdk version 1.8` で始まる値が含まれており、Java コンパイラバージョンの出力は値 `javac 1.8` から始まります。
## ステップ 2: コードを追加する
AWS Cloud9 IDE で、次のコードでファイルを作成し、 という名前でファイルを保存します`hello.java`。(メニューバーでファイルを作成するには、**ファイル**、**New File (新しいファイル)**を選択します。 ファイルを保存するには、**ファイル**、**保存**を選択します。)
```
public class hello {
public static void main(String []args) {
System.out.println("Hello, World!");
System.out.println("The sum of 2 and 3 is 5.");
int sum = Integer.parseInt(args[0]) + Integer.parseInt(args[1]);
System.out.format("The sum of %s and %s is %s.\n",
args[0], args[1], Integer.toString(sum));
}
}
```
## ステップ 3: コードを構築して実行する
1. Java コンパイラのコマンドラインバージョンを使用して、`hello.java` ファイルを `hello.class` ファイルにコンパイルします。これを行うには、IDE AWS Cloud9 のターミナルを使用して、 `hello.java` ファイルと同じディレクトリから、 `hello.java` ファイルを指定して Java コンパイラを実行します。
```
javac hello.java
```
1. Java ランナーのコマンドラインバージョンを使用して `hello.class` ファイルを実行します。これを行うには、`hello.class` ファイルと同じディレクトリから、追加する 2 つの整数 (`hello` と `hello.java` など) を使用して、`5` ファイルで宣言した `9` クラスの名前を指定します。
```
java hello 5 9
```
1. 出力を比較します。
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## ステップ 4: を使用するように を設定する AWS SDK for Java
このサンプルを強化して、 AWS SDK for Java を使用して Amazon S3 バケットを作成し、使用可能なバケットを一覧表示してから、先ほど作成したバケットを削除できます。
このステップでは、[Apache Maven](https://maven.apache.org/) または [Gradle](https://gradle.org/) を 環境にインストールします。Maven と Gradle は、Java プロジェクトで使用できる共通構築自動化システムです。Maven または Gradle をインストールしたら、新しい Java プロジェクトの生成に使用します。この新しいプロジェクトでは、 AWS SDK for Javaへの参照を追加します。これにより AWS SDK for Java 、Java コードから Amazon S3 などの AWS サービスとやり取りするのに便利です。
**Topics**
+ [Maven を使用して設定する](#sample-java-sdk-maven)
+ [Gradle を使用して設定する](#sample-java-sdk-gradle)
### Maven を使用して設定する
1. 環境に Maven をインストールします。Maven が既にインストールされているかどうかを確認するには、IDE AWS Cloud9 のターミナルを使用して、 **`-version`**オプションを使用して Maven を実行します。
```
mvn -version
```
成功すると、出力に Maven のバージョン番号が表示されます。Maven が既にインストールされている場合、この手順のステップ 4 に進んで Maven を使用し、環境で新しい Java プロジェクトを生成します。
1. ターミナルを使用して次のコマンドを実行し、Maven をインストールします。
Amazon Linux の場合、以下のコマンドは、Maven が保存されているパッケージリポジトリに関する情報を取得し、この情報を使用して Maven をインストールします。
```
sudo wget http://repos.fedorapeople.org/repos/dchen/apache-maven/epel-apache-maven.repo -O /etc/yum.repos.d/epel-apache-maven.repo
sudo sed -i s/\$releasever/6/g /etc/yum.repos.d/epel-apache-maven.repo
sudo yum install -y apache-maven
```
上記のコマンドの詳細については、Fedora Project Wiki ウェブサイトの「[Extra Packages for Enterprise Linux (EPEL)](https://docs.fedoraproject.org/en-US/epel/)」を参照してください。
Ubuntu サーバーでは、代わりに以下のコマンドを実行します。
```
sudo apt install -y maven
```
1. **`-version`** オプションを指定して Maven を実行し、インストールされていることを確認します。
```
mvn -version
```
1. 新しい Java プロジェクトを生成するには Maven を使用します。これを行うには、ターミナルを使用して、Maven によってプロジェクトを生成するディレクトリから次のコマンドを実行します (環境のルートディレクトリなど)。
```
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
```
前述のコマンドは、環境でプロジェクトの次のディレクトリ構造を作成します。
```
my-app
|- src
| `- main
| `- java
| `- com
| `- mycompany
| `- app
| `-App.java
|- test
| `- java
| `- com
| `- mycompany
| `- app
| `- AppTest.java
`- pom.xml
```
上記のディレクトリ構図の詳細については、Apache Maven プロジェクトウェブサイトの「[Maven Quickstart Archetype](https://maven.apache.org/archetypes/maven-archetype-quickstart/)」と「[Introduction to the Standard Directory Layout](https://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html)」を参照してください。
1. プロジェクトのプロジェクトオブジェクトモデル (POM) ファイルを変更します (POM ファイルは Maven プロジェクトの設定を定義します)。これを行うには、［**Environment (環境)**］ウィンドウで `my-app/pom.xml` ファイルを開きます。エディタで、ファイルの現在の内容を次のコードに置き換えて、`pom.xml` ファイルを保存します。
```
4.0.0
com.mycompany.app
my-app
jar
1.0-SNAPSHOT
org.apache.maven.plugins
maven-assembly-plugin
3.6.0
jar-with-dependencies
com.mycompany.app.App
package
single
junit
junit
3.8.1
test
com.amazonaws
aws-java-sdk
1.11.330
```
上記の POM ファイルには、以下のように宣言を指定するプロジェクト設定が含まれています。
+ `artifactid` の `my-app` 設定は、プロジェクトのルートディレクトリを設定し、`group-id` の `com.mycompany.app` 設定は `com/mycompany/app` および `package` ファイルで `App.Java` サブディレクトリ構造と `AppTest.java` 宣言を設定します。
+ `artifactId` の `my-app` 設定に加えて、`packaging` の `jar` 設定、`version` の `1.0-SNAPSHOT` 設定、`descriptorRef` の `jar-with-dependencies` 設定は、出力 JAR ファイルの `my-app-1.0-SNAPSHOT-jar-with-dependencies.jar` の名前を設定します。
+ `plugin` セクションは、構築されるすべての依存関係が含まれている単一の JAR を宣言します。
+ `groupId` を に設定`com.amazon.aws`し、 を `artifactId`に設定している `dependency`セクションには、 AWS SDK for Java ライブラリファイル`aws-java-sdk`が含まれています。使用する AWS SDK for Java バージョンは、`version` 設定で宣言します。別のバージョンを使用するには、このバージョン番号を置き換えます。
[ステップ 5: 環境で AWS 認証情報管理を設定する](#sample-java-sdk-creds) に進んでください。
### Gradle を使用して設定する
1. 環境に Gradle をインストールします。Gradle が既にインストールされているかどうかを確認するには、IDE AWS Cloud9 のターミナルを使用して、 **`-version`**オプションを使用して Gradle を実行します。
```
gradle -version
```
成功すると、出力に Gradle のバージョン番号が表示されます。Gradle が既にインストールされている場合、この手順のステップ 4 に進んで Gradle を使用し、環境で新しい Java プロジェクトを生成します。
1. ターミナルを使用して以下のコマンドを実行し、Gradle をインストールします。以下のコマンドでは、SDKMAN\$1 ツールをインストールして実行し、次に SDKMAN\$1 を使用して最新バージョンの Node.js をインストールします。
```
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install gradle
```
上記のコマンドの詳細については、SDKMAN\$1 ウェブサイトの「[Installation](https://sdkman.io/install)」と Gradle ウェブサイトの「[Install with a package manager](https://gradle.org/install/#with-a-package-manager)」を参照してください。
1. **`-version`** オプションを指定して Gradle を実行し、インストールされていることを確認します。
```
gradle -version
```
1. Gradle を使用して、環境に新しい Java プロジェクトを生成します。これを行うには、ターミナルを使用し、次のコマンドを実行してプロジェクトのディレクトリを作成した後、そのディレクトリに切り替えます。
```
mkdir my-app
cd my-app
```
1. 次のコマンドを実行して、Gradle が 環境の `my-app` ディレクトリに新しい Java アプリケーションプロジェクトを生成するようにします。
```
gradle init --type java-application
```
前述のコマンドは、環境でプロジェクトの次のディレクトリ構造を作成します。
```
my-app
|- .gradle
| `- (various supporting project folders and files)
|- gradle
| `- (various supporting project folders and files)
|- src
| |- main
| | `- java
| | `- App.java
| `- test
| `- java
| `- AppTest.java
|- build.gradle
|- gradlew
|- gradlew.bat
`- settings.gradle
```
1. プロジェクトの `AppTest.java` を変更します (これを行わない場合、プロジェクトが正常にビルドまたは実行されない可能性があります)。これを行うには、［**Environment (環境)**］ウィンドウで `my-app/src/test/java/AppTest.java` ファイルを開きます。エディタで、ファイルの現在の内容を次のコードに置き換えて、`AppTest.java` ファイルを保存します。
```
import org.junit.Test;
import static org.junit.Assert.*;
public class AppTest {
@Test public void testAppExists () {
try {
Class.forName("com.mycompany.app.App");
} catch (ClassNotFoundException e) {
fail("Should have a class named App.");
}
}
}
```
1. プロジェクトの `build.gradle` ファイルを変更します (`build.gradle` ファイルは Gradle プロジェクトの設定を定義します)。これを行うには、［**Environment (環境)**］ウィンドウで `my-app/build.gradle` ファイルを開きます。エディタで、ファイルの現在の内容を次のコードに置き換えて、`build.gradle` ファイルを保存します。
```
apply plugin: 'java'
apply plugin: 'application'
repositories {
jcenter()
mavenCentral()
}
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath "io.spring.gradle:dependency-management-plugin:1.0.3.RELEASE"
}
}
apply plugin: "io.spring.dependency-management"
dependencyManagement {
imports {
mavenBom 'com.amazonaws:aws-java-sdk-bom:1.11.330'
}
}
dependencies {
compile 'com.amazonaws:aws-java-sdk-s3'
testCompile group: 'junit', name: 'junit', version: '4.12'
}
run {
if (project.hasProperty("appArgs")) {
args Eval.me(appArgs)
}
}
mainClassName = 'App'
```
上記の `build.gradle` ファイルには、以下のように宣言を指定するプロジェクト設定が含まれています。
+ `io.spring.dependency-management` プラグインは、 AWS SDK for Java Maven 部品表 (BOM) をインポートしてプロジェクトの AWS SDK for Java 依存関係を管理するために使用されます。 は使用するバージョンを`classpath`宣言します。別のバージョンを使用するには、このバージョン番号を置き換えます。
+ `com.amazonaws:aws-java-sdk-s3` には、 AWS SDK for Java ライブラリファイルの Amazon S3 の部分が含まれています。使用するバージョンは `mavenBom` で宣言します。別のバージョンを使用する場合、このバージョン番号を置き換えます。
## ステップ 5: 環境で AWS 認証情報管理を設定する
を使用して AWS サービスを AWS SDK for Java 呼び出すたびに、呼び出しで一連の AWS 認証情報を指定する必要があります。これらの認証情報は、 にその呼び出しを行うための適切なアクセス許可 AWS SDK for Java があるかどうかを決定します。認証情報に適切なアクセス権限がない場合は、呼び出しは失敗します。
このステップでは、環境内に認証情報を保存します。これを行うには、[の環境 AWS のサービス からの呼び出し AWS Cloud9](credentials.md) の手順を実行してから、このトピックに戻ります。
詳細については、*AWS SDK for Java デベロッパーガイド*の「[開発用の AWS 認証情報とリージョンのセットアップ](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html#setup-credentials)」を参照してください。
## ステップ 6: AWS SDK コードを追加する
このステップでは、Amazon S3 を操作してバケットを作成し、使用可能なバケットの一覧を表示した後、作成したバケットを削除するコードを追加します。
［**Environment (環境)**］ウィンドウから、Maven の場合は `my-app/src/main/java/com/mycompany/app/App.java` ファイルを開き、Gradle の場合は `my-app/src/main/java/App.java` ファイルを開きます。エディタで、ファイルの現在の内容を次のコードに置き換えて、`App.java` ファイルを保存します。
```
package com.mycompany.app;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.AmazonS3Exception;
import com.amazonaws.services.s3.model.Bucket;
import com.amazonaws.services.s3.model.CreateBucketRequest;
import java.util.List;
public class App {
private static AmazonS3 s3;
public static void main(String[] args) {
if (args.length < 2) {
System.out.format("Usage: \n" +
"Example: my-test-bucket us-east-2\n");
return;
}
String bucket_name = args[0];
String region = args[1];
s3 = AmazonS3ClientBuilder.standard()
.withCredentials(new ProfileCredentialsProvider())
.withRegion(region)
.build();
// List current buckets.
ListMyBuckets();
// Create the bucket.
if (s3.doesBucketExistV2(bucket_name)) {
System.out.format("\nCannot create the bucket. \n" +
"A bucket named '%s' already exists.", bucket_name);
return;
} else {
try {
System.out.format("\nCreating a new bucket named '%s'...\n\n", bucket_name);
s3.createBucket(new CreateBucketRequest(bucket_name, region));
} catch (AmazonS3Exception e) {
System.err.println(e.getErrorMessage());
}
}
// Confirm that the bucket was created.
ListMyBuckets();
// Delete the bucket.
try {
System.out.format("\nDeleting the bucket named '%s'...\n\n", bucket_name);
s3.deleteBucket(bucket_name);
} catch (AmazonS3Exception e) {
System.err.println(e.getErrorMessage());
}
// Confirm that the bucket was deleted.
ListMyBuckets();
}
private static void ListMyBuckets() {
List buckets = s3.listBuckets();
System.out.println("My buckets now are:");
for (Bucket b : buckets) {
System.out.println(b.getName());
}
}
}
```
## ステップ 7: AWS SDK コードを構築して実行する
前のステップからコードを実行するには、ターミナルから以下のコマンドを実行します。これらのコマンドは、Maven または Gradle を使用してプロジェクトの実行可能な JAR ファイルを作成した後、Java ランナーを使用して JAR を実行します。JAR は、Amazon S3 で作成するバケットの名前 ( など`my-test-bucket`) と、バケットを作成する AWS リージョンの ID ( など) を入力として実行します`us-east-2`。
Maven の場合、以下のコマンドを実行します。
```
cd my-app
mvn package
java -cp target/my-app-1.0-SNAPSHOT-jar-with-dependencies.jar com.mycompany.app.App my-test-bucket us-east-2
```
Gradle の場合、以下のコマンドを実行します。
```
gradle build
gradle run -PappArgs="['my-test-bucket', 'us-east-2']"
```
結果を以下の出力と比較します。
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## ステップ 8: クリーンアップする
このサンプルの使用が完了したら、 AWS アカウントへの継続的な課金を防ぐには、環境を削除する必要があります。手順については、「[での環境の削除 AWS Cloud9](delete-environment.md)」を参照してください。
# の C\$1\$1 チュートリアル AWS Cloud9
このチュートリアルでは、 AWS Cloud9 開発環境で C\$1\$1 コードを実行できます。このコードは、[AWS SDK for C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/welcome.html)で提供されたリソースも使用できます。Amazon Web Services に接続するために使用できる、モジュール化されたクロスプラットフォームのオープンソースライブラリです。
このチュートリアルに従い、このサンプルを作成すると、 AWS アカウントに料金が発生する可能性があります。Amazon EC2 や Amazon S3 などのサービスに対して発生する可能性がある料金も含まれます。詳細については、「[Amazon EC2 料金表](https://aws.amazon.com/ec2/pricing/)」および「[Amazon S3 料金表](https://aws.amazon.com/s3/pricing/)」を参照してください。
**Topics**
+ [前提条件](#sample-cplusplus-prereqs)
+ [ステップ1：g \$1\$1と必要な dev パッケージをインストールする](#sample-cplusplus-install)
+ [ステップ2：CMakeをインストールする](#install-cmake)
+ [ステップ 3: SDK for C\$1\$1 の取得と構築](#install-cmake)
+ [ステップ4：C \$1\$1および CMakeLists ファイルを作成する](#sample-cplusplus-sdk-code)
+ [ステップ 5: C\$1\$1 コードを構築および実行する](#build-and-run-cpp)
+ [ステップ 6: クリーンアップする](#sample-cplusplus-clean-up)
## 前提条件
このサンプルを使用する前に、設定が次の要件を満たしていることを確認します。
+ **既存の AWS Cloud9 EC2 開発環境が必要です。**このサンプルは、Amazon Linux または Ubuntu Server を実行する Amazon EC2 インスタンスに接続された EC2 環境が既にあることを前提としています。別のタイプの環境またはオペレーティングシステムがある場合、このサンプルの指示を関連ツールを設定する必要がある場合があります。詳細については、「[での環境の作成 AWS Cloud9](create-environment.md)」を参照してください。
+ **既存の環境の AWS Cloud9 IDE が既に開いている。**環境を開くと、 はウェブブラウザでその環境の IDE AWS Cloud9 を開きます。詳細については、「[で環境を開く AWS Cloud9](open-environment.md)」を参照してください。
## ステップ1：g \$1\$1と必要な dev パッケージをインストールする
C\$1\$1 アプリケーションを構築して実行するには、`g++` など、[GNUコンパイラコレクション (GCC)](https://gcc.gnu.org/)によって提供される C \$1\$1コンパイラであるユーティリティが必要です。
また、ヘッダーファイル (`-dev`パッケージ) を `libcurl`、`libopenssl`、`libuuid`、`zlib`、およびオプションで、`libpulse` Amazon Polly のサポートのため追加する必要があります。
開発ツールをインストールするプロセスは、Amazon Linux/Amazon Linux 2 インスタンスと Ubuntu インスタンスのどちらを使用しているかによって若干異なります。
------
#### [ Amazon Linux-based systems ]
AWS Cloud9 ターミナルで次のコマンドを実行して、 が既に`gcc`インストールされているかどうかを確認できます。
```
g++ --version
```
もし `g++` がインストールされていない場合は、「開発ツール」と呼ばれるパッケージグループのパートを簡単にインストールできます。これらのツールは、`yum groupinstall`コマンドでインスタンスに追加:
```
sudo yum groupinstall "Development Tools"
```
`g++ --version` を再度実行して、コンパイラがインストールされていることを確認します。
次に、システムのパッケージマネージャを使用して、必要なライブラリのパッケージをインストールします。
```
sudo yum install libcurl-devel openssl-devel libuuid-devel pulseaudio-libs-devel
```
------
#### [ Ubuntu-based systems ]
AWS Cloud9 ターミナルで次のコマンドを実行して、 が既に`gcc`インストールされているかどうかを確認できます。
```
g++ --version
```
gcc がインストールされていない場合は、次のコマンドを実行して Ubuntu ベースのシステムにインストールできます。
```
sudo apt update
sudo apt install build-essential
sudo apt-get install manpages-dev
```
`g++ --version` を再度実行して、コンパイラがインストールされていることを確認します。
次に、システムのパッケージマネージャを使用して、必要なライブラリのパッケージをインストールします。
```
sudo apt-get install libcurl4-openssl-dev libssl-dev uuid-dev zlib1g-dev libpulse-dev
```
------
## ステップ2：CMakeをインストールする
`cmake` ツールをインストールする必要があります。このツールは、ソースコードから実行可能ファイルを構築するプロセスを自動化します。
1. IDE のターミナルウィンドウで、次のコマンドを実行して、必要なアーカイブを取得します。
```
wget https://cmake.org/files/v3.18/cmake-3.18.0.tar.gz
```
1. アーカイブからファイルを抽出し、解凍したファイルが含まれているディレクトリに移動します。
```
tar xzf cmake-3.18.0.tar.gz
cd cmake-3.18.0
```
1. 次に、ブートストラップスクリプトを実行し、次のコマンドを実行して `cmake` をインストールします。
```
./bootstrap
make
sudo make install
```
1. 次のコマンドを実行して、ツールがインストールされていることを確認します。
```
cmake --version
```
## ステップ 3: SDK for C\$1\$1 の取得と構築
AWS SDK for C\$1\$1 を設定するには、ソースから直接 SDK を構築するか、パッケージマネージャーを使用してライブラリをダウンロードします。使用可能なオプションの詳細については、「 *AWS SDK for C\$1\$1 デベロッパーガイド*[」の AWS 「 SDK for C\$1\$1 の使用開始](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/getting-started.html)」を参照してください。
このサンプルは `git` の使用を示し、SDK ソースコードと `cmake` のクローンを作成して、SDK for C\$1\$1 を構築します。
1. ターミナルで次のコマンドを実行して、リモートリポジトリをクローンし、 AWS Cloud9 環境のため、すべての git サブモジュールを再帰的に取得します。
```
git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp
```
1. 新しい`aws-sdk-cpp`ディレクトリに移動し、 AWS SDK for C\$1\$1 を構築するためのサブディレクトリを作成し、それに移動します。
```
cd aws-sdk-cpp
mkdir sdk_build
cd sdk_build
```
1.
**注記**
時間を節約するため、このステップは、 AWS SDK for C\$1\$1の Amazon S3 部分のみを構築します。完全なSDKを構築したいのであれば、`cmake` コマンドから `-DBUILD_ONLY=s3` を省略します。
完全な SDK for C\$1\$1 を構築すると、Amazon EC2 インスタンスまたは自分のサーバーで使用できるコンピューティングリソースに応じて、完了までに 1 時間を超えることがあります。
`cmake` を使って、次のコマンドを実行して `sdk_build` ディレクトリに SDK for C\$1\$1 の Amazon S3 の部分を構築します。
```
cmake .. -DBUILD_ONLY=s3
```
1. では、`make install` コマンドを実行して、ビルドされた SDK にアクセスできるようにします。
```
sudo make install
cd ..
```
## ステップ4：C \$1\$1および CMakeLists ファイルを作成する
このステップでは、`C++` ファイルを作成し、プロジェクトのユーザーに Amazon S3 バケットと対話を許可します。
また、`CMakeLists.txt` ファイルを作成して、C \$1\$1ライブラリを構築するために、`cmake` で使用する指示を提供します。
1. AWS Cloud9 IDE で、このコンテンツを含むファイルを作成し、 という名前のファイルを環境のルート (`/`) `s3-demo.cpp` に保存します。
```
#include
#include
#include
#include
#include
#include
#include
// Look for a bucket among all currently available Amazon S3 buckets.
bool FindTheBucket(const Aws::S3::S3Client &s3Client,
const Aws::String &bucketName) {
Aws::S3::Model::ListBucketsOutcome outcome = s3Client.ListBuckets();
if (outcome.IsSuccess()) {
std::cout << "Looking for a bucket named '" << bucketName << "'..."
<< std::endl << std::endl;
Aws::Vector bucket_list =
outcome.GetResult().GetBuckets();
for (Aws::S3::Model::Bucket const &bucket: bucket_list) {
if (bucket.GetName() == bucketName) {
std::cout << "Found the bucket." << std::endl << std::endl;
return true;
}
}
std::cout << "Could not find the bucket." << std::endl << std::endl;
} else {
std::cerr << "listBuckets error: "
<< outcome.GetError().GetMessage() << std::endl;
}
return outcome.IsSuccess();
}
// Create an Amazon S3 bucket.
bool CreateTheBucket(const Aws::S3::S3Client &s3Client,
const Aws::String &bucketName,
const Aws::String ®ion) {
std::cout << "Creating a bucket named '"
<< bucketName << "'..." << std::endl << std::endl;
Aws::S3::Model::CreateBucketRequest request;
request.SetBucket(bucketName);
if (region != "us-east-1") {
Aws::S3::Model::CreateBucketConfiguration createBucketConfig;
createBucketConfig.SetLocationConstraint(
Aws::S3::Model::BucketLocationConstraintMapper::GetBucketLocationConstraintForName(
region));
request.SetCreateBucketConfiguration(createBucketConfig);
}
Aws::S3::Model::CreateBucketOutcome outcome =
s3Client.CreateBucket(request);
if (outcome.IsSuccess()) {
std::cout << "Bucket created." << std::endl << std::endl;
} else {
std::cerr << "createBucket error: "
<< outcome.GetError().GetMessage() << std::endl;
}
return outcome.IsSuccess();
}
// Delete an existing Amazon S3 bucket.
bool DeleteTheBucket(const Aws::S3::S3Client &s3Client,
const Aws::String &bucketName) {
std::cout << "Deleting the bucket named '"
<< bucketName << "'..." << std::endl << std::endl;
Aws::S3::Model::DeleteBucketRequest request;
request.SetBucket(bucketName);
Aws::S3::Model::DeleteBucketOutcome outcome =
s3Client.DeleteBucket(request);
if (outcome.IsSuccess()) {
std::cout << "Bucket deleted." << std::endl << std::endl;
} else {
std::cerr << "deleteBucket error: "
<< outcome.GetError().GetMessage() << std::endl;
}
return outcome.IsSuccess();
}
#ifndef EXCLUDE_MAIN_FUNCTION
// Create an S3 bucket and then delete it.
// Before and after creating the bucket, and again after deleting the bucket,
// try to determine whether that bucket still exists.
int main(int argc, char *argv[]) {
if (argc < 3) {
std::cout << "Usage: s3-demo " << std::endl
<< "Example: s3-demo my-bucket us-east-1" << std::endl;
return 1;
}
Aws::SDKOptions options;
Aws::InitAPI(options);
{
Aws::String bucketName = argv[1];
Aws::String region = argv[2];
Aws::Client::ClientConfiguration config;
config.region = region;
Aws::S3::S3Client s3Client(config);
if (!FindTheBucket(s3Client, bucketName)) {
return 1;
}
if (!CreateTheBucket(s3Client, bucketName, region)) {
return 1;
}
if (!FindTheBucket(s3Client, bucketName)) {
return 1;
}
if (!DeleteTheBucket(s3Client, bucketName)) {
return 1;
}
if (!FindTheBucket(s3Client, bucketName)) {
return 1;
}
}
Aws::ShutdownAPI(options);
return 0;
}
#endif // EXCLUDE_MAIN_FUNCTION
```
1. このコンテンツを含んだ 2 番目のファイルを作成し、環境のルート (`/`) に `CMakeLists.txt` という名前をつけてファイルを保存します。このファイルを使用すると、コードを実行可能ファイルに組み込むことができます。
```
# A minimal CMakeLists.txt file for the AWS SDK for C++.
# The minimum version of CMake that will work.
cmake_minimum_required(VERSION 2.8)
# The project name.
project(s3-demo)
# Locate the AWS SDK for C++ package.
set(AWSSDK_ROOT_DIR, "/usr/local/")
set(BUILD_SHARED_LIBS ON)
find_package(AWSSDK REQUIRED COMPONENTS s3)
# The executable name and its source files.
add_executable(s3-demo s3-demo.cpp)
# The libraries used by your executable.
target_link_libraries(s3-demo ${AWSSDK_LINK_LIBRARIES})
```
## ステップ 5: C\$1\$1 コードを構築および実行する
1. `s3-demo.cpp` と`CMakeLists.txt` を保存した環境のルートディレクトリで、`cmake` を実行してプロジェクトを構築します。
```
cmake .
make
```
1. これで、コマンドラインからプログラムを実行できます。次のコマンドで、`my-unique-bucket-name` を Amazon S3 バケットの一意の名前に置き換え、必要であれば、`us-east-1` を別の AWS リージョン (バケットを作成したい場所)の識別子に置き換えます。
```
./s3-demo my-unique-bucket-name us-east-1
```
プログラムが正常に実行された場合は、次のような出力が返されます。
```
Looking for a bucket named 'my-unique-bucket-name'...
Could not find the bucket.
Creating a bucket named 'my-unique-bucket-name'...
Bucket created.
Looking for a bucket named 'my-unique-bucket-name'...
Found the bucket.
Deleting the bucket named 'my-unique-bucket-name'...
Bucket deleted.
Looking for a bucket named 'my-unique-bucket-name'...
Could not find the bucket.
```
## ステップ 6: クリーンアップする
このサンプルの使用が終了した後、 AWS アカウントへの継続的な課金を防ぐには、環境を削除します。手順については、「[での環境の削除 AWS Cloud9](delete-environment.md)」を参照してください。
# の Python チュートリアル AWS Cloud9
このチュートリアルでは、 AWS Cloud9 開発環境で Python コードを実行する方法を示します。
このチュートリアルに従うと、 AWS アカウントに料金が発生する可能性があります。これには、Amazon Elastic Compute Cloud (Amazon EC2) や Amazon Simple Storage Service (Amazon S3) などのサービスに対して発生しうる料金が含まれます。詳細については、「[Amazon EC2 料金表](https://aws.amazon.com/ec2/pricing/)」および「[Amazon S3 料金表](https://aws.amazon.com/s3/pricing/)」を参照してください。
**Topics**
+ [前提条件](#sample-python-prereqs)
+ [ステップ 1: Python をインストールする](#sample-python-install)
+ [ステップ 2: コードを追加する](#sample-python-code)
+ [ステップ 3: コードを実行する](#sample-python-run)
+ [ステップ 4: をインストールして設定する AWS SDK for Python (Boto3)](#sample-python-sdk)
+ [ステップ 5: AWS SDK コードを追加する](#sample-python-sdk-code)
+ [ステップ 6: AWS SDK コードを実行する](#sample-python-sdk-run)
+ [ステップ 7: クリーンアップする](#sample-python-clean-up)
## 前提条件
このチュートリアルを使用する前に、以下の前提条件を満たしていることを確認します。
+ ** AWS Cloud9 EC2 開発環境がある**
このチュートリアルでは、EC2 環境があり、環境が Amazon Linux または Ubuntu Serverを実行している Amazon EC2 インスタンス に接続されているという前提を立てています。詳細については、「[EC2 環境を作成する](create-environment-main.md)」を参照してください。
別のタイプの環境またはオペレーティングシステムを使用している場合は、このチュートリアルの手順の調整が必要になる場合があります。
+ **その環境の AWS Cloud9 IDE を開いた**
環境を開くと、 はウェブブラウザでその環境の IDE AWS Cloud9 を開きます。詳細については、「[で環境を開く AWS Cloud9](open-environment.md)」を参照してください。
## ステップ 1: Python をインストールする
1. AWS Cloud9 IDE のターミナルセッションで、 ** `python --version` ** コマンドを実行して Python が既にインストールされているかどうかを確認します。(新しいターミナルセッションを開始するには、メニューバーで、[**Window (ウィンドウ)**]、[**New Terminal (新しいターミナル)**] の順に選択します。) Python がインストール済みである場合は、[ステップ 2: コードを追加する](#sample-python-code) に進んでください。
1. ** `yum update`** (Amazon Linux 用) または **`apt update`** (Ubuntu Server 用) コマンドを実行して、最新のセキュリティ更新プログラムおよびバグ修正がインストールされていることを確認します。
Amazon Linux の場合:
```
sudo yum -y update
```
Ubuntu Server の場合:
```
sudo apt update
```
1. **`install`** コマンドを実行して Python をインストールします。
Amazon Linux の場合:
```
sudo yum -y install python3
```
Ubuntu Server の場合:
```
sudo apt-get install python3
```
## ステップ 2: コードを追加する
AWS Cloud9 IDE で、次の内容のファイルを作成し、 という名前でファイルを保存します`hello.py`。(ファイルを作成するには、メニューバーで**ファイル**、**New File (新しいファイル)**を選択します。 ファイルを保存するには、**ファイル**,**保存**を選択します。)
```
import sys
print('Hello, World!')
print('The sum of 2 and 3 is 5.')
sum = int(sys.argv[1]) + int(sys.argv[2])
print('The sum of {0} and {1} is {2}.'.format(sys.argv[1], sys.argv[2], sum))
```
## ステップ 3: コードを実行する
1. AWS Cloud9 IDE のメニューバーで、**Run**、**Run Configurations**、**New Run Configuration** を選択します。
1. **［新規］- 停止**タブ、**コマンド**に、`hello.py 5 9` を入力します。コード内の `5` は `sys.argv[1]` を、`9` は `sys.argv[2]` を表します。
1. [**Run (実行)**] を選択して、出力を比較します。
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
1. デフォルトでは、 はコードのランナー AWS Cloud9 を自動的に選択します。ランナーを変更するには、[**Runner (ランナー)**] を選択し、[**Python 2**] または [**Python 3**] を選択します。
**注記**
特定のバージョンの Python 用にカスタムランナーを作成できます。詳細については、「[ビルダーまたはランナーを作成する](build-run-debug.md#build-run-debug-create-builder-runner)」を参照してください。
## ステップ 4: をインストールして設定する AWS SDK for Python (Boto3)
AWS SDK for Python (Boto3) を使用すると、Python コードを使用して Amazon S3 などの AWS サービスとやり取りできます。たとえば、SDK を使用して Amazon S3 バケットを作成し、利用可能なバケットを一覧表示して、作成したばかりのバケットを削除できます。
### pip をインストールします。
AWS Cloud9 IDE で、 ** `python -m pip --version` ** コマンドを実行して、 `pip`が Python のアクティブバージョンに既にインストールされているかどうかを確認します。`pip` がインストール済みである場合は、次のセクションに進みます。
次のコマンドを実行して `pip` をインストールします。sudo の環境はユーザーの環境と異なるため、使用する Python のバージョンが現在のエイリアスバージョンと異なる場合は、バージョンを指定する必要があります。
```
curl -O https://bootstrap.pypa.io/get-pip.py # Get the install script.
sudo python3 get-pip.py # Install pip for Python 3.
python -m pip --version # Verify pip is installed.
rm get-pip.py # Delete the install script.
```
詳細については、`pip` ウェブサイトの「[インストール](https://pip.pypa.io/en/stable/installing/)」を参照してください。
### のインストール AWS SDK for Python (Boto3)
をインストールしたら`pip`、 ** `pip install` ** コマンド AWS SDK for Python (Boto3) を実行して をインストールします。
```
sudo python3 -m pip install boto3 # Install boto3 for Python 3.
python -m pip show boto3 # Verify boto3 is installed for the current version of Python.
```
詳細については、[の「](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html)クイックスタート AWS SDK for Python (Boto3)」セクションの「インストール」を参照してください。
### ステップ 2: 環境 で認証情報管理を設定する
を使用して AWS サービスを AWS SDK for Python (Boto3) 呼び出すたびに、呼び出しで一連の認証情報を指定する必要があります。これらの認証情報により、呼び出しに必要なアクセス許可が SDK にあるかどうかを判断します。認証情報に必要なアクセス許可がない場合、呼び出しは失敗します。
認証情報を環境に保存するには、[の環境 AWS のサービス からの呼び出し AWS Cloud9](credentials.md) の手順を実行してから、このトピックに戻ります。
詳細については、『[』の「](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html)認証情報 AWS SDK for Python (Boto3)」を参照してください。
## ステップ 5: AWS SDK コードを追加する
Amazon S3 を使用してバケットを作成するコードを追加し、使用可能なバケットを一覧表示して、任意でバケットを削除します。
AWS Cloud9 IDE で、次の内容のファイルを作成し、 という名前でファイルを保存します`s3.py`。
```
import sys
import boto3
from botocore.exceptions import ClientError
def list_my_buckets(s3_resource):
print("Buckets:\n\t", *[b.name for b in s3_resource.buckets.all()], sep="\n\t")
def create_and_delete_my_bucket(s3_resource, bucket_name, keep_bucket):
list_my_buckets(s3_resource)
try:
print("\nCreating new bucket:", bucket_name)
bucket = s3_resource.create_bucket(
Bucket=bucket_name,
CreateBucketConfiguration={
"LocationConstraint": s3_resource.meta.client.meta.region_name
},
)
except ClientError as e:
print(
f"Couldn't create a bucket for the demo. Here's why: "
f"{e.response['Error']['Message']}"
)
raise
bucket.wait_until_exists()
list_my_buckets(s3_resource)
if not keep_bucket:
print("\nDeleting bucket:", bucket.name)
bucket.delete()
bucket.wait_until_not_exists()
list_my_buckets(s3_resource)
else:
print("\nKeeping bucket:", bucket.name)
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("bucket_name", help="The name of the bucket to create.")
parser.add_argument("region", help="The region in which to create your bucket.")
parser.add_argument(
"--keep_bucket",
help="Keeps the created bucket. When not "
"specified, the bucket is deleted "
"at the end of the demo.",
action="store_true",
)
args = parser.parse_args()
s3_resource = (
boto3.resource("s3", region_name=args.region)
if args.region
else boto3.resource("s3")
)
try:
create_and_delete_my_bucket(s3_resource, args.bucket_name, args.keep_bucket)
except ClientError:
print("Exiting the demo.")
if __name__ == "__main__":
main()
```
## ステップ 6: AWS SDK コードを実行する
1. メニューバーで、［**Run (実行)**］、［**Run Configurations (実行設定)**］、［**New Run Configuration (新しい実行設定)**］の順に選択します。
1. **コマンド**には、 と入力します。ここで`s3.py my-test-bucket us-west-2`、 `my-test-bucket` は作成するバケットの名前、 `us-west-2`はバケットが作成される AWS リージョンの ID です。デフォルトでは、バケットはスクリプトが終了する前に削除されます。バケットを保持するには、コマンドに `--keep_bucket` を追加します。 AWS リージョン IDs、の[「Amazon Simple Storage Service のエンドポイントとクォータ](https://docs.aws.amazon.com/general/latest/gr/s3.html)」を参照してください*AWS 全般のリファレンス*。
**注記**
Amazon S3 バケット名は、アカウント AWS だけでなく AWS、 全体で一意である必要があります。
1. [**Run (実行)**] を選択して、出力を比較します。
```
Buckets:
a-pre-existing-bucket
Creating new bucket: my-test-bucket
Buckets:
a-pre-existing-bucket
my-test-bucket
Deleting bucket: my-test-bucket
Buckets:
a-pre-existing-bucket
```
## ステップ 7: クリーンアップする
このチュートリアルを完了した後、 AWS アカウントへの継続的な課金を防ぐには、 AWS Cloud9 環境を削除します。手順については、「[での環境の削除 AWS Cloud9](delete-environment.md)」を参照してください。
# の .NET チュートリアル AWS Cloud9
このチュートリアルでは、 AWS Cloud9 開発環境でいくつかの .NET コードを実行できます。
このチュートリアルに従い、このサンプルを作成すると、 AWS アカウントに料金が発生する可能性があります。Amazon EC2 や Amazon S3 などのサービスに対して発生する可能性がある料金も含まれます。詳細については、「[Amazon EC2 料金表](https://aws.amazon.com/ec2/pricing/)」および「[Amazon S3 料金表](https://aws.amazon.com/s3/pricing/)」を参照してください。
**Topics**
+ [前提条件](#sample-dotnetcore-prereqs)
+ [ステップ 1: 必要なツールをインストールする](#sample-dotnetcore-setup)
+ [ステップ 2。(オプション): Lambda 関数用の .NET CLI 拡張をインストールする](#sample-dotnetcore-lambda)
+ [ステップ 3: .NET コンソールアプリケーションプロジェクトを作成する](#sample-dotnetcore-app)
+ [ステップ 4: コードを追加する](#sample-dotnetcore-code)
+ [ステップ 5: コードを構築および実行する](#sample-dotnetcore-run)
+ [ステップ 6: を使用する .NET コンソールアプリケーションプロジェクトを作成してセットアップする AWS SDK for .NET](#sample-dotnetcore-sdk)
+ [ステップ 7: AWS SDK コードを追加する](#sample-dotnetcore-sdk-code)
+ [ステップ 8: AWS SDK コードを構築して実行する](#sample-dotnetcore-sdk-run)
+ [ステップ 9: クリーンアップする。](#sample-dotnetcore-clean-up)
## 前提条件
このサンプルを使用する前に、設定が次の要件を満たしていることを確認します。
+ **既存の AWS Cloud9 EC2 開発環境が必要です。**このサンプルは、Amazon Linux または Ubuntu Server を実行する Amazon EC2 インスタンスに接続された EC2 環境が既にあることを前提としています。別のタイプの環境またはオペレーティングシステムがある場合、このサンプルの指示を関連ツールを設定する必要がある場合があります。詳細については、「[での環境の作成 AWS Cloud9](create-environment.md)」を参照してください。
+ **既存の環境の AWS Cloud9 IDE が既に開いている。**環境を開くと、 はウェブブラウザでその環境の IDE AWS Cloud9 を開きます。詳細については、「[で環境を開く AWS Cloud9](open-environment.md)」を参照してください。
## ステップ 1: 必要なツールをインストールする
このステップでは、このサンプルの実行に必要な .NET SDK を環境にインストールします。
1. .NET SDK の最新バージョンが環境に既にインストールされているかどうかを確認します。これを行うには、IDE AWS Cloud9 のターミナルセッションで、 **`--version`**オプションを使用して .NET Core コマンドラインインターフェイス (CLI) を実行します。
```
dotnet --version
```
.NET コマンドラインツールのバージョンが表示され、バージョンが 2.0 以上の場合、[ステップ 3: .NET コンソールアプリケーションプロジェクトを作成する](#sample-dotnetcore-app) まで進みます。バージョンが 2.0 より古い場合、または `bash: dotnet: command not found` などのエラーが表示された場合は、.NET SDK のインストールを続行します。
1. Amazon Linux の場合、IDE AWS Cloud9 のターミナルセッションで次のコマンドを実行して、最新のセキュリティ更新プログラムとバグ修正がインストールされていることを確認し、.NET SDK に必要な`libunwind`パッケージをインストールします。(新しいターミナルセッションを開始するには、メニューバーで、[**Window (ウィンドウ)]、[New Terminal (新しいターミナル)**] の順に選択します。)
```
sudo yum -y update
sudo yum -y install libunwind
```
Ubuntu Server の場合、IDE AWS Cloud9 のターミナルセッションで次のコマンドを実行して、最新のセキュリティ更新プログラムとバグ修正がインストールされていることを確認します。(新しいターミナルセッションを開始するには、メニューバーで、[**Window (ウィンドウ)]、[New Terminal (新しいターミナル)**] の順に選択します。)
```
sudo apt -y update
```
1. 次のコマンドを実行して、.NET SDK インストーラスクリプトを環境にダウンロードします。
```
wget https://dot.net/v1/dotnet-install.sh
```
1. 次のコマンドを実行して、インストールスクリプトを現在のユーザーに実行可能にします。
```
sudo chmod u=rx dotnet-install.sh
```
1. 次のコマンドを実行して、.NET SDK をダウンロードし、インストールするインストーラスクリプトを実行します。
```
./dotnet-install.sh -c Current
```
1. `PATH` に .NET SDK を追加します。これを行うには、次のように、環境のシェルプロファイル (たとえば、`.bashrc`ファイル) で、`$HOME/.dotnet` サブディレクトリを環境の `PATH` 変数に追加します。
1. `.bashrc` ** `vi` コマンドを使用して、** ファイルを編集のために開きます。
```
vi ~/.bashrc
```
1. Amazon Linux では、下向き矢印または `j` キーを使用して、`export PATH` で始まる行に移動します。
Ubuntu Server では、「`G`」と入力して、ファイルの最後の行に移動します。
1. 右向き矢印または `$` キーを使用して、行の末尾に移動します。
1. `i` キーを押して挿入モードに切り替えます (表示の末尾に `-- INSERT ---` と表示されます)。
1. Amazon Linux の場合、`:$HOME/.dotnet` を入力することで、`$HOME/.dotnet` サブディレクトリを** `PATH` **変数に追加します。必ずコロン文字 (`:`) を入力します。行は以下のようになります。
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet
```
Ubuntu Server では、右矢印キーを押し、`Enter` を 2 回押してから、ファイルの末尾に次の行を単独で入力します。
```
export PATH=$HOME/.dotnet:$PATH
```
1. ファイルを保存します。これを行うには、`Esc` キーを押して (`-- INSERT ---` が表示の末尾から消えます)、`:wq` と入力し (ファイルに書き込んで終了します)、`Enter` キーを押します。
1. `.bashrc` ファイルをソースに指定して、.NET SDK をロードします。
```
. ~/.bashrc
```
1. **`--help`** オプションで .NET CLI を実行することにより、.NET SDK がロードされることを確認します。
```
dotnet --help
```
成功した場合、.NET SDK のバージョン番号が、その他の使用状況情報と共に表示されます。
1. 環境に .NET SDK インストーラスクリプトを保持する必要がなくなった場合は、次の方法で削除できます。
```
rm dotnet-install.sh
```
## ステップ 2。(オプション): Lambda 関数用の .NET CLI 拡張をインストールする
このチュートリアルでは必須ではありませんが、 `Amazon.Lambda.Tools`パッケージもインストールする場合は、.NET CLI を使用して AWS Lambda 関数と AWS Serverless Application Model アプリケーションをデプロイできます。
1. 次のコマンドを実行して、このパッケージをインストールします。
```
dotnet tool install -g Amazon.Lambda.Tools
```
1. 今、`PATH` および `DOTNET_ROOT` 環境変数を設定して、インストールされた Lambda ツールを指します。`.bashrc` ファイルを見つけるには `export PATH` セクションを開き、次のように表示されるように編集します (このファイルの編集の詳細については、ステップ 1 を参照してください)。
```
export PATH=$PATH:$HOME/.local/bin:$HOME/bin:$HOME/.dotnet:$HOME/.dotnet/tools
export DOTNET_ROOT=$HOME/.dotnet
```
## ステップ 3: .NET コンソールアプリケーションプロジェクトを作成する
このステップでは、.NET を使用して `hello` という名前のプロジェクトを作成します。このプロジェクトには、.NET が IDE のターミナルからシンプルなアプリケーションを実行するのに必要なすべてのファイルが含まれています。アプリケーションのコードは C\$1 で書かれています。
.NET コンソールアプリケーションプロジェクトを作成します。これを行うには、**`new`** コマンドを使用して .NET CLI を実行します。次のように、使用するコンソールアプリケーションオブジェクトテンプレートのタイプとプログラミング言語 (このサンプルでは C\$1) を指定します。
`-n` オプションは、プロジェクトが新しいディレクトリ `hello` に出力されることを示します。続いて、 そのディレクトリに移動します。
```
dotnet new console -lang C# -n hello
cd hello
```
前述のコマンドは、いくつかのファイルを含む `obj` という名前のサブディレクトリを追加し、追加のスタンドアロンファイルを `hello` ディレクトリに追加します。次の 2 つのキーファイルに注意してください。
+ `hello/hello.csproj` ファイルには、コンソールアプリケーションプロジェクトに関する情報が含まれています。
+ `hello/Program.cs` ファイルには、実行するアプリケーションのコードが含まれています。
## ステップ 4: コードを追加する
このステップでは、アプリケーションにコードを追加します。
IDE AWS Cloud9 の**環境**ウィンドウから、 `hello/Program.cs` ファイルを開きます。
エディタで、ファイルの現在の内容を次のコードに置き換えて、`Program.cs` ファイルを保存します。
```
using System;
namespace hello
{
class Program
{
static void Main(string[] args)
{
if (args.Length < 2) {
Console.WriteLine("Please provide 2 numbers");
return;
}
Console.WriteLine("Hello, World!");
Console.WriteLine("The sum of 2 and 3 is 5.");
int sum = Int32.Parse(args[0]) + Int32.Parse(args[1]);
Console.WriteLine("The sum of {0} and {1} is {2}.",
args[0], args[1], sum);
}
}
}
```
## ステップ 5: コードを構築および実行する
このステップでは、プロジェクトとその依存関係を、実行可能なアプリケーションファイルを含む 1 つのバイナリファイルのセットに構築します。次にアプリケーションを実行します。
1. IDE では、次のように .NET のビルダーを作成します。
1. メニューバーで、**[Run (実行)]、[Build System (ビルドシステム)]、[New Build System (新しいビルドシステム)]** の順に選択します。
1. [**My Builder.build**] タブで、タブの内容を以下のコードに置き換えます。
```
{
"cmd" : ["dotnet", "build"],
"info" : "Building..."
}
```
1. ［**File (ファイル)］、［Save As (名前を付けて保存)**］の順に選択します。
1. [**Filename (ファイル名)**] に「`.NET.build`」と入力します。
1. [**Folder (フォルダ)**] に「`/.c9/builders`」と入力します。
1. **[保存]** を選択します。
1. エディタに `Program.cs` ファイルの内容を表示した状態で、**[実行]、[ビルドシステム]、[.NET]** の順に選択します。次に、**[Run (実行)]、[Build (ビルド)]** を選択します。
このビルダは、`bin` という名前のサブディレクトリを追加し、`Debug` という名前のサブディレクトリを `hello/obj` サブディレクトリに追加します。次の 3 つのキーファイルに注意してください。
+ この `hello/bin/Debug/netcoreapp3.1/hello.dll` ファイルは、実行可能なアプリケーションファイルです。
+ `hello/bin/Debug/netcoreapp3.1/hello.deps.json` ファイルは、アプリケーションの依存関係をリストします。
+ `hello/bin/Debug/netcoreapp3.1/hello.runtimeconfig.json` ファイルは、アプリケーションの共有ランタイムとそのバージョンを指定します。
**注記**
フォルダ名 `netcoreapp3.1` は、この例で使用されている .NET SDK のバージョンを反映しています。インストールしているバージョンによっては、フォルダ名に異なる番号が表示される場合があります。
1. 次のように、.NET のランナーを作成します。
1. メニューバーで、**[Run (実行)]、[Run With (次で実行)]、[New Runner (新しいランナー)]** の順に選択します。
1. [**My Runner.run**] タブで、タブの内容を以下のコードに置き換えます。
```
{
"cmd" : ["dotnet", "run", "$args"],
"working_dir": "$file_path",
"info" : "Running..."
}
```
1. ［**File (ファイル)］、［Save As (名前を付けて保存)**］の順に選択します。
1. [**Filename (ファイル名)**] に「`.NET.run`」と入力します。
1. [**Folder (フォルダ)**] に「`/.c9/runners`」と入力します。
1. **[保存]** を選択します。
1. 追加する 2 つの整数を指定してアプリケーションを実行します (例: `5`、`9`) を追加します。
1. エディタに `Program.cs` ファイルの内容を表示した状態で、**[Run (実行)]、[Run Configurations (実行設定)]、[New Run Configuration (新しい実行設定)]** の順に選択します。
1. **[[新規] - アイドル]** タブで、**[ランナー: 自動]** を選択し、**[.NET]** を選択します。
1. [**Command (コマンド)**] ボックスに、「`hello 5 9`」と入力します。
1. **[Run]** (実行) を選択します。
デフォルトでは、このランナーは .NET に `hello/bin/Debug/netcoreapp3.1` ディレクトリで `hello.dll` ファイルを実行するよう指示します。
出力を以下と比較します。
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## ステップ 6: を使用する .NET コンソールアプリケーションプロジェクトを作成してセットアップする AWS SDK for .NET
このサンプルを強化して、 AWS SDK for .NET を使用して Amazon S3 バケットを作成し、使用可能なバケットを一覧表示してから、先ほど作成したバケットを削除できます。
この新しいプロジェクトでは、 AWS SDK for .NETへの参照を追加します。 AWS SDK for .NET は、.NET コードから Amazon S3 などの AWS サービスとやり取りする便利な方法を提供します。次に、 環境で AWS 認証情報管理を設定します。が AWS サービスとやり取りするには、これらの認証情報 AWS SDK for .NET が必要です。
### プロジェクトを作成するには
1. .NET コンソールアプリケーションプロジェクトを作成します。これを行うには、使用するコンソールアプリケーションプロジェクトのテンプレートタイプとプログラミング言語を指定し、**`new`** コマンドを使用して .NET CLI を実行します。
`-n` オプションは、プロジェクトが新しいディレクトリ `s3` に出力されることを示します。続いて、 そのディレクトリに移動します。
```
dotnet new console -lang C# -n s3
cd s3
```
1. AWS SDK for .NETで Amazon S3 パッケージへのプロジェクトリファレンスを追加します。これを行うには、NuGet で Amazon S3 パッケージの名前を指定し、**`add package`** コマンドを使用して .NET Core を実行します。(NuGet では、.NET のパッケージを作成、ホスト、使用する方法が定義され、それらのロールごとにツールが用意されています)。
```
dotnet add package AWSSDK.S3
```
Amazon S3 パッケージにプロジェクトリファレンスを追加すると、NuGet は AWS SDK for .NETの他の部分にもプロジェクトリファレンスを追加します。
**注記**
NuGet の他の AWS 関連パッケージの名前とバージョンについては、[NuGet ウェブサイトの「aws-sdk でタグ付けされた NuGet パッケージ](https://www.nuget.org/packages?q=Tags%3A%22aws-sdk%22)」を参照してください。 NuGet
### AWS 認証情報管理を設定するには
を使用して AWS サービスを AWS SDK for .NET 呼び出すたびに、呼び出しで一連の AWS 認証情報を指定する必要があります。これらの認証情報は、 にその呼び出しを行うための適切なアクセス許可 AWS SDK for .NET があるかどうかを決定します。認証情報に適切なアクセス権限がない場合は、呼び出しは失敗します。
認証情報を環境に保存するには、[の環境 AWS のサービス からの呼び出し AWS Cloud9](credentials.md) の指示を実行してから、このトピックに戻ります。
詳細については、「 *AWS SDK for .NET デベロッパーガイド*」の[AWS 「認証情報の設定](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html)」を参照してください。
## ステップ 7: AWS SDK コードを追加する
このステップでは、Amazon S3 を操作してバケットを作成し、作成したばかりのバケットを削除した後、利用できるバケットのリストを表示するコードを追加します。
IDE AWS Cloud9 の**環境**ウィンドウから、 `s3/Program.cs` ファイルを開きます。エディタで、ファイルの現在の内容を次のコードに置き換えて、`Program.cs` ファイルを保存します。
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using Amazon.S3.Util;
using System;
using System.Threading.Tasks;
namespace s3
{
class Program
{
async static Task Main(string[] args)
{
if (args.Length < 2) {
Console.WriteLine("Usage: ");
Console.WriteLine("Example: my-test-bucket us-east-2");
return;
}
if (args[1] != "us-east-2") {
Console.WriteLine("Cannot continue. The only supported AWS Region ID is " +
"'us-east-2'.");
return;
}
var bucketRegion = RegionEndpoint.USEast2;
// Note: You could add more valid AWS Regions above as needed.
using (var s3Client = new AmazonS3Client(bucketRegion)) {
var bucketName = args[0];
// Create the bucket.
try
{
if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
{
Console.WriteLine("Cannot continue. Cannot create bucket. \n" +
"A bucket named '{0}' already exists.", bucketName);
return;
} else {
Console.WriteLine("\nCreating the bucket named '{0}'...", bucketName);
await s3Client.PutBucketAsync(bucketName);
}
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Cannot continue. {0}", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Cannot continue. {0}", e.Message);
}
// Confirm that the bucket was created.
if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
{
Console.WriteLine("Created the bucket named '{0}'.", bucketName);
} else {
Console.WriteLine("Did not create the bucket named '{0}'.", bucketName);
}
// Delete the bucket.
Console.WriteLine("\nDeleting the bucket named '{0}'...", bucketName);
await s3Client.DeleteBucketAsync(bucketName);
// Confirm that the bucket was deleted.
if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
{
Console.WriteLine("Did not delete the bucket named '{0}'.", bucketName);
} else {
Console.WriteLine("Deleted the bucket named '{0}'.", bucketName);
};
// List current buckets.
Console.WriteLine("\nMy buckets now are:");
var response = await s3Client.ListBucketsAsync();
foreach (var bucket in response.Buckets)
{
Console.WriteLine(bucket.BucketName);
}
}
}
}
}
```
## ステップ 8: AWS SDK コードを構築して実行する
このステップでは、プロジェクトとその依存関係を、実行可能なアプリケーションファイルを含む 1 つのバイナリファイルのセットに構築します。次にアプリケーションを実行します。
1. プロジェクトをビルドします。これを行うには、エディタに `s3/Program.cs` ファイルの内容を表示した状態で、**[Run (実行)]、[Build (ビルド)]** の順に選択します。
1. 次のように、作成する Amazon S3 バケットの名前と、バケットを作成する AWS リージョンの ID (例: `my-test-bucket` と `us-east-2`) をがついたアプリケーションを実行します。
1. エディタに `s3/Program.cs` ファイルの内容を表示した状態で、**[Run (実行)]、[Run Configurations (実行設定)]、[New Run Configuration (新しい実行設定)]** の順に選択します。
1. **[[新規] - アイドル]** タブで、**[ランナー: 自動]** を選択し、**[.NET]** を選択します。
1. **コマンド**ボックスに、アプリケーションの名前、作成する Amazon S3 バケットの名前、バケットを作成する AWS リージョンの ID (例: ) を入力します`s3 my-test-bucket us-east-2`。
1. **[Run]** (実行) を選択します。
デフォルトでは、このランナーは .NET に `s3/bin/Debug/netcoreapp3.1` ディレクトリで `s3.dll` ファイルを実行するよう指示します。
結果を以下の出力と比較します。
```
Creating a new bucket named 'my-test-bucket'...
Created the bucket named 'my-test-bucket'.
Deleting the bucket named 'my-test-bucket'...
Deleted the bucket named 'my-test-bucket'.
My buckets now are:
```
## ステップ 9: クリーンアップする。
このサンプルの使用が完了したら、 AWS アカウントへの継続的な課金を防ぐには、環境を削除する必要があります。手順については、「[での環境の削除 AWS Cloud9](delete-environment.md)」を参照してください。
# の Node.js チュートリアル AWS Cloud9
このチュートリアルでは、 AWS Cloud9 開発環境でいくつかの Node.js スクリプトを実行できます。
このチュートリアルに従い、このサンプルを作成すると、 AWS アカウントに料金が発生する可能性があります。Amazon EC2 や Amazon S3 などのサービスに対して発生する可能性がある料金も含まれます。詳細については、「[Amazon EC2 料金表](https://aws.amazon.com/ec2/pricing/)」および「[Amazon S3 料金表](https://aws.amazon.com/s3/pricing/)」を参照してください。
**Topics**
+ [前提条件](#sample-nodejs-prereqs)
+ [ステップ 1: 必要なツールをインストールする](#sample-nodejs-install)
+ [ステップ 2: コードを追加する](#sample-nodejs-code)
+ [ステップ 3: コードを実行する](#sample-nodejs-run)
+ [ステップ 4: Node.js で AWS SDK for JavaScript をインストールして設定する](#sample-nodejs-sdk)
+ [ステップ 5: AWS SDK コードを追加する](#sample-nodejs-sdk-code)
+ [ステップ 6: AWS SDK コードを実行する](#sample-nodejs-sdk-run)
+ [ステップ 7: クリーンアップする](#sample-nodejs-clean-up)
## 前提条件
このサンプルを使用する前に、設定が次の要件を満たしていることを確認します。
+ **既存の AWS Cloud9 EC2 開発環境が必要です。**このサンプルは、Amazon Linux または Ubuntu Server を実行する Amazon EC2 インスタンスに接続された EC2 環境が既にあることを前提としています。別のタイプの環境またはオペレーティングシステムがある場合、このサンプルの指示を関連ツールを設定する必要がある場合があります。詳細については、「[での環境の作成 AWS Cloud9](create-environment.md)」を参照してください。
+ **既存の環境の AWS Cloud9 IDE が既に開いている。**環境を開くと、 はウェブブラウザでその環境の IDE AWS Cloud9 を開きます。詳細については、「[で環境を開く AWS Cloud9](open-environment.md)」を参照してください。
## ステップ 1: 必要なツールをインストールする
このステップでは Node.js をインストールして設定します。このサンプルを実行するために必要なものです。
1. AWS Cloud9 IDE のターミナルセッションで、 ** `node --version` ** コマンドを実行して Node.js が既にインストールされているかどうかを確認します。(新しいターミナルセッションを開始するには、メニューバーで、［**Window (ウィンドウ)**]、［**New Termina］(新しいターミナル)**] の順に選択します。) 成功すると、出力に Node.js のバージョン番号が表示されます。Node.js がインストール済みである場合は、[ステップ 2: コードを追加する](#sample-nodejs-code)に進んでください。
1. (Amazon Linux の場合) ** `yum update` ** または (Ubuntu Server の場合) ** `apt update` ** コマンドを実行して、最新のセキュリティ更新プログラムおよびバグ修正がインストールされていることを確認します。
Amazon Linux の場合:
```
sudo yum -y update
```
Ubuntu Server の場合:
```
sudo apt update
```
1. Node.js をインストールするには、まず、次のコマンドを実行して Node Version Manager (nvm) をダウンロードします。(nvm は、Node.js のバージョンをインストールして管理するために役立つシンプルな Bash シェルスクリプトです。詳細については、GitHub ウェブサイトの「[Node Version Manager](https://github.com/creationix/nvm/blob/master/README.md)」を参照してください。)
```
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.5/install.sh | bash
```
1. nvm の使用を開始するには、ターミナルセッションを閉じてもう一度起動するか、nvm をロードするコマンドを含む `~/.bashrc` ファイルを入手します。
```
. ~/.bashrc
```
1. このコマンドを実行して、Amazon Linux 2、Amazon Linux 1、および Ubuntu 18.04 に Node.js 16 をインストールします。Amazon Linux 1 インスタンスと Ubuntu 18.04 インスタンスは v16 までの Node.js のみをサポートします。
```
nvm install 16
```
このコマンドを実行して、Amazon Linux 2023 および Ubuntu 22.04 に最新バージョンの Node.js をインストールします。
```
nvm install --lts && nvm alias default lts/*
```
**注記**
最新の AL2023 AWS Cloud9 image には Node.js 20 がインストールされ、最新の Amazon Linux 2 AWS Cloud9 image には Node.js 18 がインストールされています。Amazon Linux 2 に Node.js 18 AWS Cloud9 を手動でインストールする場合は、IDE AWS Cloud9 ターミナルで次のコマンドを実行します。
```
C9_NODE_INSTALL_DIR=~/.nvm/versions/node/v18.17.1
C9_NODE_URL=https://d3kgj69l4ph6w4.cloudfront.net/static/node-amazon/node-v18.17.1-linux-x64.tar.gz
mkdir -p $C9_NODE_INSTALL_DIR
curl -fSsl $C9_NODE_URL | tar xz --strip-components=1 -C "$C9_NODE_INSTALL_DIR"
nvm alias default v18.17.1
nvm use default
echo -e 'nvm use default' >> ~/.bash_profile
```
## ステップ 2: コードを追加する
AWS Cloud9 IDE で、このコンテンツを含むファイルを作成し、 という名前でファイルを保存します`hello.js`。(メニューバーでファイルを作成するには、**ファイル**、**New File (新しいファイル)**を選択します。 ファイルを保存するには、**ファイル**、**保存**を選択します。)
```
console.log('Hello, World!');
console.log('The sum of 2 and 3 is 5.');
var sum = parseInt(process.argv[2], 10) + parseInt(process.argv[3], 10);
console.log('The sum of ' + process.argv[2] + ' and ' +
process.argv[3] + ' is ' + sum + '.');
```
## ステップ 3: コードを実行する
1. AWS Cloud9 IDE のメニューバーで、**実行**、**設定の実行**、**新しい実行設定**を選択します。
1. ［**［New] - Id］e (［新規] - アイドル)**] タブで、［**Runner: Auto (ランナー: 自動)**] を選択し、［**Node.js**] を選択します。
1. ［**Command (コマンド)**] に「`hello.js 5 9`」と入力します。このコードで、`5` は `process.argv[2]` を表し、`9` は `process.argv[3]` を表します (`process.argv[0]` はランタイム (`node`) の名前、`process.argv[1]` はファイル (`hello.js`) の名前です)。
1. ［**Run (実行)**] ボタンを選択して、出力を比較します。
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[IDE でコードを実行した後の Node.js AWS Cloud9 出力\]](http://docs.aws.amazon.com/ja_jp/cloud9/latest/user-guide/images/ide-nodejs-simple.png)
## ステップ 4: Node.js で AWS SDK for JavaScript をインストールして設定する
で Node.js スクリプトを実行する場合 AWS Cloud9、 AWS SDK for JavaScript バージョン 3 (V3) と古い AWS SDK for JavaScript バージョン 2 (V2) のいずれかを選択できます。V2 と同様に V3 を使用すると、Amazon Web Services を簡単に操作できますが、TypeScript で記述されており、モジュール化されたパッケージなど、頻繁にリクエストされる複数の機能が追加されています。
------
#### [ AWS SDK for JavaScript (V3) ]
このサンプルを強化して、Node.js で AWS SDK for JavaScript を使用して Amazon S3 バケットを作成し、使用可能なバケットを一覧表示してから、作成したばかりのバケットを削除できます。
このステップでは、 AWS SDK for JavaScript in Node.js の Amazon S3 サービスクライアントモジュールをインストールして設定しますが、そうすれば、JavaScript コードから、Amazon S3 AWS サービスを簡単に操作できるようになります。
他の AWS サービスを使用する場合は、個別にインストールする必要があります。 AWS モジュールのインストールの詳細については、「 [*AWS デベロッパーガイド (V3)*」の「」を参照してください。](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/working-with-services)Node.js と AWS SDK for JavaScript (V3) の使用を開始する方法については、 SDK for JavaScript [ 開発者ガイド (V3) の「Node.js の使用を開始する](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/getting-started-nodejs.html#getting-started-nodejs-setup-structure)」を参照してください。 *AWS JavaScript *
Node.js に AWS SDK for JavaScript をインストールしたら、 環境で認証情報管理を設定する必要があります。Node.js の AWS SDK for JavaScript では、 サービスとやり取り AWS するためにこれらの認証情報が必要です。
**Node.js に AWS SDK for JavaScript をインストールするには**
npm を使用して **`install`** コマンドを実行します。
```
npm install @aws-sdk/client-s3
```
詳細については、*AWS SDK for JavaScript デベロッパーガイド*の「[SDK for JavaScript のインストール](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-up.html#installing-jssdk)」を参照してください。
**環境で認証情報管理を設定するには**
Node.js で AWS SDK for JavaScript を使用して AWS サービスを呼び出すたびに、呼び出しで一連の認証情報を指定する必要があります。これらの認証情報は AWS SDK for JavaScript in Node.js にその呼び出しを行う適切な許可があるかどうかを判別します。認証情報に適切なアクセス権限がない場合、呼び出しは失敗します。
このステップでは、環境内に認証情報を保存します。これを行うには、[の環境 AWS のサービス からの呼び出し AWS Cloud9](credentials.md) の手順を実行してから、このトピックに戻ります。
詳細については、*AWS SDK for JavaScript デベロッパーガイド*の「[Setting Credentials in Node.js (Noda.jp に認証情報を設定)](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/setting-credentials-node.html)」を参照してください。
------
#### [ AWS SDK for JavaScript (V2) ]
このサンプルを強化して、Node.js で AWS SDK for JavaScript を使用して Amazon S3 バケットを作成し、使用可能なバケットを一覧表示してから、作成したばかりのバケットを削除できます。
このステップでは、 AWS SDK for JavaScript を Node.js にインストールして設定します。これにより、JavaScript コードから Amazon S3 などの AWS サービスとやり取りする便利な方法が提供されます。Node.js に AWS SDK for JavaScript をインストールしたら、環境で認証情報管理を設定する必要があります。Node.js の AWS SDK for JavaScript では、 サービスとやり取り AWS するためにこれらの認証情報が必要です。
**Node.js に AWS SDK for JavaScript をインストールするには**
npm を使用して **`install`** コマンドを実行します。
```
npm install aws-sdk
```
詳細については、*AWS SDK for JavaScript デベロッパーガイド*の「[SDK for JavaScript のインストール](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/installing-jssdk.html)」を参照してください。
**環境で認証情報管理を設定するには**
Node.js で AWS SDK for JavaScript を使用して AWS サービスを呼び出すたびに、呼び出しで一連の認証情報を指定する必要があります。これらの認証情報は AWS SDK for JavaScript in Node.js にその呼び出しを行う適切な許可があるかどうかを判別します。認証情報に適切なアクセス権限がない場合、呼び出しは失敗します。
このステップでは、環境内に認証情報を保存します。これを行うには、[の環境 AWS のサービス からの呼び出し AWS Cloud9](credentials.md) の手順を実行してから、このトピックに戻ります。
詳細については、*AWS SDK for JavaScript デベロッパーガイド*の「[Setting Credentials in Node.js (Noda.jp に認証情報を設定)](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/setting-credentials-node.html)」を参照してください。
------
## ステップ 5: AWS SDK コードを追加する
------
#### [ AWS SDK for JavaScript (V3) ]
このステップでは、今度は Amazon S3 を操作してバケットを作成し、利用できるバケットのリストを表示した後、作成したバケットを削除するコードをいくつか追加します。このコードは後で実行します。
AWS Cloud9 IDE で、このコンテンツを含むファイルを作成し、 という名前でファイルを保存します`s3.js`。
```
import {
CreateBucketCommand,
DeleteBucketCommand,
ListBucketsCommand,
S3Client,
} from "@aws-sdk/client-s3";
const wait = async (milliseconds) => {
return new Promise((resolve) => setTimeout(resolve, milliseconds));
};
export const main = async () => {
const client = new S3Client({});
const now = Date.now();
const BUCKET_NAME = `easy-bucket-${now.toString()}`;
const createBucketCommand = new CreateBucketCommand({ Bucket: BUCKET_NAME });
const listBucketsCommand = new ListBucketsCommand({});
const deleteBucketCommand = new DeleteBucketCommand({ Bucket: BUCKET_NAME });
try {
console.log(`Creating bucket ${BUCKET_NAME}.`);
await client.send(createBucketCommand);
console.log(`${BUCKET_NAME} created`);
await wait(2000);
console.log(`Here are your buckets:`);
const { Buckets } = await client.send(listBucketsCommand);
Buckets.forEach((bucket) => {
console.log(` • ${bucket.Name}`);
});
await wait(2000);
console.log(`Deleting bucket ${BUCKET_NAME}.`);
await client.send(deleteBucketCommand);
console.log(`${BUCKET_NAME} deleted`);
} catch (err) {
console.error(err);
}
};
main();
```
------
#### [ AWS SDK for JavaScript (V2) ]
このステップでは、今度は Amazon S3 を操作してバケットを作成し、利用できるバケットのリストを表示した後、作成したバケットを削除するコードをいくつか追加します。このコードは後で実行します。
AWS Cloud9 IDE で、このコンテンツを含むファイルを作成し、 という名前でファイルを保存します`s3.js`。
```
if (process.argv.length < 4) {
console.log(
"Usage: node s3.js \n" +
"Example: node s3.js my-test-bucket us-east-2"
);
process.exit(1);
}
var AWS = require("aws-sdk"); // To set the AWS credentials and region.
var async = require("async"); // To call AWS operations asynchronously.
AWS.config.update({
region: region,
});
var s3 = new AWS.S3({ apiVersion: "2006-03-01" });
var bucket_name = process.argv[2];
var region = process.argv[3];
var create_bucket_params = {
Bucket: bucket_name,
CreateBucketConfiguration: {
LocationConstraint: region,
},
};
var delete_bucket_params = { Bucket: bucket_name };
// List all of your available buckets in this AWS Region.
function listMyBuckets(callback) {
s3.listBuckets(function (err, data) {
if (err) {
} else {
console.log("My buckets now are:\n");
for (var i = 0; i < data.Buckets.length; i++) {
console.log(data.Buckets[i].Name);
}
}
callback(err);
});
}
// Create a bucket in this AWS Region.
function createMyBucket(callback) {
console.log("\nCreating a bucket named " + bucket_name + "...\n");
s3.createBucket(create_bucket_params, function (err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Delete the bucket you just created.
function deleteMyBucket(callback) {
console.log("\nDeleting the bucket named " + bucket_name + "...\n");
s3.deleteBucket(delete_bucket_params, function (err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Call the AWS operations in the following order.
async.series([
listMyBuckets,
createMyBucket,
listMyBuckets,
deleteMyBucket,
listMyBuckets,
]);
```
------
## ステップ 6: AWS SDK コードを実行する
1. npm を使用して ** `install` ** コマンドを実行すると、コードによる Amazon S3 オペレーションの非同期的に呼び出しが有効になります。
```
npm install async
```
1. AWS Cloud9 IDE のメニューバーで、**実行**、**実行設定**、**新しい実行設定**を選択します。
1. ［**［New] - Id］e (［新規] - アイドル)**] タブで、［**Runner: Auto (ランナー: 自動)**] を選択し、［**Node.js**] を選択します。
1. AWS SDK for JavaScript (V3) を使用している場合は、 **コマンド**タイプ に `s3.js`。 AWS SDK for Javascript (v2) を使用している場合、**コマンド**タイプ の場合`s3.js my-test-bucket us-east-2`、 `my-test-bucket`は作成して削除するバケットの名前、 `us-east-2`はバケットを作成する AWS リージョンの ID です。他の ID については、[の「](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)Amazon Simple Storage Service (Amazon S3)*Amazon Web Services 全般のリファレンス*」を参照してください。
**注記**
Amazon S3 バケット名は、アカウント AWS だけでなく AWS、 全体で一意である必要があります。
1. ［**実行**］ボタンを選択して、出力を比較します。
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## ステップ 7: クリーンアップする
このサンプルの使用が完了した後に AWS アカウントで継続的に課金されないようにするには、環境を削除する必要があります。手順については、[での環境の削除 AWS Cloud9](delete-environment.md) を参照してください。
# の PHP チュートリアル AWS Cloud9
このチュートリアルでは、 AWS Cloud9 開発環境でいくつかの PHP スクリプトを実行できます。
このチュートリアルに従って、このサンプルを作成すると、 AWS アカウントに料金が発生する可能性があります。Amazon EC2 や Amazon S3 などのサービスに対して発生する可能性がある料金も含まれます。詳細については、「[Amazon EC2 料金表](https://aws.amazon.com/ec2/pricing/)」および「[Amazon S3 料金表](https://aws.amazon.com/s3/pricing/)」を参照してください。
**Topics**
+ [前提条件](#sample-php-prereqs)
+ [ステップ 1: 必要なツールをインストールする](#sample-php-install)
+ [ステップ 2: コードを追加する](#sample-php-code)
+ [ステップ 3: コードを実行する](#sample-php-run)
+ [ステップ 4: をインストールして設定する AWS SDK for PHP](#sample-php-sdk)
+ [ステップ 5: AWS SDK コードを追加する](#sample-php-sdk-code)
+ [ステップ 6: AWS SDK コードを実行する](#sample-php-sdk-run)
+ [ステップ 7: クリーンアップする](#sample-php-clean-up)
## 前提条件
このサンプルを使用する前に、設定が次の要件を満たしていることを確認します。
+ **既存の AWS Cloud9 EC2 開発環境が必要です。**このサンプルは、Amazon Linux または Ubuntu Server を実行する Amazon EC2 インスタンスに接続された EC2 環境が既にあることを前提としています。別のタイプの環境またはオペレーティングシステムがある場合、このサンプルの指示を関連ツールを設定する必要がある場合があります。詳細については、「[での環境の作成 AWS Cloud9](create-environment.md)」を参照してください。
+ **既存の環境の AWS Cloud9 IDE が既に開いている。**環境を開くと、 はウェブブラウザでその環境の IDE AWS Cloud9 を開きます。詳細については、「[で環境を開く AWS Cloud9](open-environment.md)」を参照してください。
## ステップ 1: 必要なツールをインストールする
このステップでは PHP をインストールして設定します。このサンプルを実行するために必要なものです。
**注記**
次の手順では、PHP のみがインストールされます。Apache ウェブサーバーや MySQL データベースなどの関連ツールをインストールするには、*Amazon EC2 ユーザーガイド*の「[チュートリアル: Amazon Linux への LAMP ウェブサーバーのインストール](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-LAMP.html)」を参照してください。
1. AWS Cloud9 IDE のターミナルセッションで、 ** `php --version` ** コマンドを実行して PHP が既にインストールされているかどうかを確認します。(新しいターミナルセッションを開始するには、メニューバーで、［**Window (ウィンドウ)**］、［**New Terminal (新しいターミナル)**］の順に選択します。) 成功すると、出力に PHP のバージョン番号が表示されます。PHP がインストール済みである場合は、[ステップ 2: コードを追加する](#sample-php-code) に進みます。
1. ** `yum update` ** (Amazon Linux 用) または ** `apt update` ** (Ubuntu Server 用) コマンドを実行して、最新のセキュリティ更新プログラムおよびバグ修正がインストールされていることを確認します。
Amazon Linux 2 および Amazon Linux:
```
sudo yum -y update
```
Ubuntu Server の場合:
```
sudo apt update
```
1. **`install`** コマンドを実行して PHP をインストールします。
複数 Amazon Linux 2:
```
sudo amazon-linux-extras install -y php7.2
```
Amazon Linux の場合:
```
sudo yum -y install php72
```
**注記**
次のコマンドを使用して、Amazon Linux のバージョンを表示できます。
```
cat /etc/system-release
```
Ubuntu Server の場合:
```
sudo apt install -y php php-xml
```
詳細については、PHP ウェブサイトの「[インストールと設定](http://php.net/manual/en/install.php)」を参照してください。
## ステップ 2: コードを追加する
AWS Cloud9 IDE で、このコンテンツを含むファイルを作成し、 という名前でファイルを保存します`hello.php`。(ファイルを作成するには、メニューバーで**ファイル**,**New File (新しいファイル)**を選択します。 ファイルを保存するには、［**ファイル**,**保存**］を選択し、［**ファイル名**］に `hello.php` と入力してから［**保存**］を選択します。)
```
```
**注記**
前述のコードは外部ファイルに依存していません。ただし、ファイルに他の PHP ファイルを含めたり要求したりし、それらのファイル AWS Cloud9 を使用して入力時にコード補完を行う場合は、**「プロジェクト」、「PHP サポート」、「PHP コード補完設定を有効にする**」を有効にしてから、それらのファイルへのパスを**「プロジェクト」、「PHP サポート」、「PHP 完了インクルードパス**」設定に追加します。 ****(設定を表示および変更するには、メニューバーで、［**AWS Cloud9］、［設定**］の順に選択します。)
## ステップ 3: コードを実行する
1. AWS Cloud9 IDE のメニューバーで、**Run**、**Run Configurations**、**New Run Configuration** を選択します。
1. ［**［New］- Idle (［新規］- アイドル)**］タブで、［**Runner: Auto (ランナー: 自動)**］を選択し、［**PHP (cli)**］を選択します。
1. ［**Command (コマンド)**］に「`hello.php 5 9`」と入力します。このコードで、`5` は `$argv[1]` を表し、`9` は `$argv[2]` を表します (`$argv[0]` はファイル名 (`hello.php`) です。)
1. ［**Run (実行)**］ボタンを選択して、出力を比較します。
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[IDE での PHP AWS Cloud9 コードの実行の出力\]](http://docs.aws.amazon.com/ja_jp/cloud9/latest/user-guide/images/ide-php-simple.png)
## ステップ 4: をインストールして設定する AWS SDK for PHP
このサンプルを強化して、 AWS SDK for PHP を使用して Amazon S3 バケットを作成し、使用可能なバケットを一覧表示してから、先ほど作成したバケットを削除できます。
このステップでは、PHP コードから Amazon S3 などの AWS サービスとやり取りする便利な方法 AWS SDK for PHPを提供する をインストールして設定します。をインストールする前に AWS SDK for PHP、[Composer](https://getcomposer.org/) をインストールする必要があります。をインストールしたら AWS SDK for PHP、 環境で認証情報管理を設定する必要があります。が AWS サービスとやり取りするには、これらの認証情報 AWS SDK for PHP が必要です。
### Composer をインストールするには
サイレント (**) とエラー表示 (`curl`) オプションを指定して ** `-s` `-S` コマンドを実行し、Composer インストーラを PHP アーカイブ (PHAR) ファイル (判りやすくするために `composer.phar` という名前にします) にパイピングします。
```
curl -sS https://getcomposer.org/installer | php
```
### をインストールするには AWS SDK for PHP
Ubuntu Server では、 AWS SDK for PHPをインストールするために Composer に必要な追加のパッケージをインストールします。
```
sudo apt install -y php-xml php-curl
```
Amazon Linux または Ubuntu Server では、**php** コマンドを使用して Composer インストーラを実行し、 AWS SDK for PHPをインストールします。
```
php composer.phar require aws/aws-sdk-php
```
このコマンドは、複数のフォルダとファイルを環境に作成します。最初に使用するファイルは `autoload.php` です。これは 環境 の `vendor` フォルダにあります。
**注記**
インストール後に、Composer から追加の依存関係をインストールすることが勧められる可能性があります。これを行うには、次のようなコマンドを使用して、インストールする依存関係のリストを指定します。たとえば、次のコマンドでは、Composer に次の依存関係のリストをインストールするように指示します。
```
php composer.phar require psr/log ext-curl doctrine/cache aws/aws-php-sns-message-validator
```
詳細については、*AWS SDK for PHP デベロッパーガイド*の「[インストール](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/installation.html)」を参照してください。
### 環境で認証情報管理を設定するには
を使用して AWS サービスを AWS SDK for PHP 呼び出すたびに、呼び出しで一連の認証情報を指定する必要があります。これらの認証情報は、 にその呼び出しを行うための適切なアクセス許可 AWS SDK for PHP があるかどうかを決定します。認証情報に適切なアクセス権限がない場合は、呼び出しは失敗します。
このステップでは、環境内に認証情報を保存します。これを行うには、[の環境 AWS のサービス からの呼び出し AWS Cloud9](credentials.md) の手順を実行してから、このトピックに戻ります。
詳細については、*AWS SDK for PHP デベロッパーガイド*にある[ベーシック用法](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/basic-usage.html)の「クライアントの作成」セクションを参照してください。
## ステップ 5: AWS SDK コードを追加する
このステップでは、今度は Amazon S3 を操作してバケットを作成し、利用できるバケットのリストを表示した後、作成したバケットを削除するコードをいくつか追加します。このコードは後で実行します。
AWS Cloud9 IDE で、このコンテンツを含むファイルを作成し、 という名前でファイルを保存します`s3.php`。
```
\n" .
"Example: php s3.php America/Los_Angeles my-test-bucket us-east-2");
}
$timeZone = $argv[1];
$bucketName = $argv[2];
$region = $argv[3];
date_default_timezone_set($timeZone);
$s3 = new Aws\S3\S3Client([
'region' => $region,
'version' => '2006-03-01'
]);
# Lists all of your available buckets in this AWS Region.
function listMyBuckets($s3)
{
print("\nMy buckets now are:\n");
$promise = $s3->listBucketsAsync();
$result = $promise->wait();
foreach ($result['Buckets'] as $bucket) {
print("\n");
print($bucket['Name']);
}
}
listMyBuckets($s3);
# Create a new bucket.
print("\n\nCreating a new bucket named '$bucketName'...\n");
try {
$promise = $s3->createBucketAsync([
'Bucket' => $bucketName,
'CreateBucketConfiguration' => [
'LocationConstraint' => $region
]
]);
$promise->wait();
} catch (Exception $e) {
if ($e->getCode() == 'BucketAlreadyExists') {
exit("\nCannot create the bucket. " .
"A bucket with the name '$bucketName' already exists. Exiting.");
}
}
listMyBuckets($s3);
# Delete the bucket you just created.
print("\n\nDeleting the bucket named '$bucketName'...\n");
$promise = $s3->deleteBucketAsync([
'Bucket' => $bucketName
]);
$promise->wait();
listMyBuckets($s3);
?>
```
## ステップ 6: AWS SDK コードを実行する
1. AWS Cloud9 IDE のメニューバーで、**Run**、**Run Configurations**、**New Run Configuration** を選択します。
1. ［**［New］- Idle (［新規］- アイドル)**］タブで、［**Runner: Auto (ランナー: 自動)**］を選択し、［**PHP (cli)**］を選択します。
1. ［**Command (コマンド)**］に「`s3.php America/Los_Angeles my-test-bucket us-east-2`」と入力します。それぞれ以下を表します。
+ `America/Los_Angeles` はデフォルトのタイムゾーン ID です。その他の ID については、PHP ウェブサイトの「[サポートされるタイムゾーンのリスト](http://php.net/manual/en/timezones.php)」を参照してください。
+ `my-test-bucket` は作成した後削除するバケットの名前です。
**注記**
Amazon S3 バケット名は、アカウント AWS だけでなく AWS、 全体で一意である必要があります。
+ `us-east-2` は、バケットを作成する AWS リージョンの ID です。他の ID については、[の「](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)Amazon Simple Storage Service (Amazon S3)*Amazon Web Services 全般のリファレンス*」を参照してください。
1. ［**実行**］ボタンを選択して、出力を比較します。
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## ステップ 7: クリーンアップする
このサンプルの使用が完了したら、 AWS アカウントへの継続的な課金を防ぐには、環境を削除する必要があります。手順については、「[での環境の削除 AWS Cloud9](delete-environment.md)」を参照してください。
### の PHP ランナーに関する問題のトラブルシューティング AWS Cloud9
PHP CLI ランナーで問題が発生した場合は、ランナーが PHP に設定され、デバッガーモードが有効になっていることを確認する必要があります。
# AWS の SDK for Ruby AWS Cloud9
AWS SDK for Ruby AWS Cloud9 で を使用する方法については、 [AWS SDK for Ruby AWS Cloud9](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/cloud9-ruby.html)*AWS デベロッパーガイドの SDK for Ruby* で を使用するを参照してください。
**注記**
このチュートリアルに従うと、 AWS アカウントに料金が発生する可能性があります。Amazon EC2 や Amazon S3 などのサービスに対して発生する可能性がある料金も含まれます。詳細については、「[Amazon EC2 料金表](https://aws.amazon.com/ec2/pricing/)」および「[Amazon S3 料金表](https://aws.amazon.com/s3/pricing/)」を参照してください。
# の Go チュートリアル AWS Cloud9
このチュートリアルでは、 AWS Cloud9 開発環境でいくつかの Go コードを実行できます。
このチュートリアルに従い、このサンプルを作成すると、 AWS アカウントに料金が発生する可能性があります。Amazon EC2 や Amazon S3 などのサービスに対して発生する可能性がある料金も含まれます。詳細については、「[Amazon EC2 料金表](https://aws.amazon.com/ec2/pricing/)」および「[Amazon S3 料金表](https://aws.amazon.com/s3/pricing/)」を参照してください。
**Topics**
+ [前提条件](#sample-go-prereqs)
+ [ステップ 1: 必要なツールをインストールする](#sample-go-install)
+ [ステップ 2: コードを追加する](#sample-go-code)
+ [ステップ 3: コードを実行する](#sample-go-run)
+ [ステップ 4: をインストールして設定する AWS SDK for Go](#sample-go-sdk)
+ [ステップ 5: AWS SDK コードを追加する](#sample-go-sdk-code)
+ [ステップ 6: AWS SDK コードを実行する](#sample-go-sdk-run)
+ [ステップ 7: クリーンアップする](#sample-go-clean-up)
## 前提条件
このサンプルを使用する前に、設定が次の要件を満たしていることを確認します。
+ **既存の AWS Cloud9 EC2 開発環境が必要です。**このサンプルは、Amazon Linux または Ubuntu Server を実行する Amazon EC2 インスタンスに接続された EC2 環境が既にあることを前提としています。別のタイプの環境またはオペレーティングシステムがある場合、このサンプルの指示を関連ツールを設定する必要がある場合があります。詳細については、「[での環境の作成 AWS Cloud9](create-environment.md)」を参照してください。
+ **既存の環境の AWS Cloud9 IDE が既に開いている。**環境を開くと、 はウェブブラウザでその環境の IDE AWS Cloud9 を開きます。詳細については、「[で環境を開く AWS Cloud9](open-environment.md)」を参照してください。
## ステップ 1: 必要なツールをインストールする
このステップでは Go をインストールして設定します。このサンプルを実行するために必要なものです。
1. AWS Cloud9 IDE のターミナルセッションで、 ** `go version` ** コマンドを実行して Go が既にインストールされているかどうかを確認します。(新しいターミナルセッションを開始するには、メニューバーで、［**Window (ウィンドウ)**］、［**New Terminal (新しいターミナル)**］の順に選択します。) 成功した場合、出力に Go のバージョン番号が含まれています。それ以外の場合は、エラーメッセージが出力されます。Go がインストール済みである場合は、[ステップ 2: コードを追加する](#sample-go-code) に進んでください。
1. (Amazon Linux) 用 ** `yum update` ** または (Ubuntu Server) 用 ** `apt update` ** コマンドを実行して、最新のセキュリティ更新プログラムおよびバグ修正がインストールされていることを確認します。
Amazon Linux の場合:
```
sudo yum -y update
```
Ubuntu Server の場合:
```
sudo apt update
```
1. Go をインストールするには、以下のコマンドを 1 つずつ実行します。
```
wget https://storage.googleapis.com/golang/go1.9.3.linux-amd64.tar.gz # Download the Go installer.
sudo tar -C /usr/local -xzf ./go1.9.3.linux-amd64.tar.gz # Install Go.
rm ./go1.9.3.linux-amd64.tar.gz # Delete the installer.
```
前述のコマンドは、このトピックが作成された時点の最新の安定バージョンの Go を前提にしています。詳細については、Go プログラミング言語ウェブサイトで「[Downloads](https://golang.org/dl/)」を参照してください。
1. Go バイナリのパスを `PATH` 環境変数に追加します。次のようになります。
1. 編集のため、シェルプロファイルのファイル (たとえば `~/.bashrc`) を開きます。
1. 次のコード行の末尾に、次のように入力します。これにより、コードは次のようになります。
```
PATH=$PATH:/usr/local/go/bin
```
1. ファイルを保存します。
1. `~/.bashrc` ファイルをソース化し、ターミナルが今参照した Go バイナリを見つけられるようにします。
```
. ~/.bashrc
```
1. **`go version`** コマンドを実行して、Go が正しくインストールおよび設定されていることを確認します。成功した場合、出力に Go のバージョン番号が含まれています。
## ステップ 2: コードを追加する
AWS Cloud9 IDE で、このコンテンツを含むファイルを作成し、 という名前でファイルを保存します`hello.go`。(メニューバーでファイルを作成するには、**ファイル**、**New File (新しいファイル)**を選択します。 ファイルを保存するには、**ファイル**、**保存**を選択します。)
```
package main
import (
"fmt"
"os"
"strconv"
)
func main() {
fmt.Printf("Hello, World!\n")
fmt.Printf("The sum of 2 and 3 is 5.\n")
first, _ := strconv.Atoi(os.Args[1])
second, _ := strconv.Atoi(os.Args[2])
sum := first + second
fmt.Printf("The sum of %s and %s is %s.",
os.Args[1], os.Args[2], strconv.Itoa(sum))
}
```
## ステップ 3: コードを実行する
1. AWS Cloud9 IDE のメニューバーで、**Run**、**Run Configurations**、**New Run Configuration** を選択します。
1. [**[New] - Idle ([新規] - アイドル)**] タブで、[**Runner: Auto (ランナー: 自動)**] を選択し、[**Go**] を選択します。
**注記**
[**Go**] が利用できない場合は、Go 用のカスタムランナーを作成できます。
[**[New] - Idle ([新規] - アイドル)**] タブで、[**Runner: Auto (ランナー: 自動)**] を選択し、[**New Runner (新しいランナー)**] を選択します。
[**My Runner.run**] タブで、タブの内容を以下のコードに置き換えます。
```
{
"cmd" : ["go", "run", "$file", "$args"],
"info" : "Running $project_path$file_name...",
"selector" : "source.go"
}
```
メニューバーで [**File (ファイル)**]、[**Save As (名前を付けて保存)**] の順に選択し、ファイルを `Go.run` として `/.c9/runners` フォルダに保存します。
[**[New] - Idle ([新規] - アイドル)**] タブで、[**Runner: Auto (ランナー: 自動)**] を選択し、[**Go**] を選択します。
[**hello.go**] タブを選択し、アクティブにします。
1. ［**Command (コマンド)**］に「`hello.go 5 9`」と入力します。コード内の `5` は `os.Args[1]` を、`9` は `os.Args[2]` を表します。
![\[IDE での Go AWS Cloud9 コードの実行の出力\]](http://docs.aws.amazon.com/ja_jp/cloud9/latest/user-guide/images/ide-go-simple.png)
1. ［**実行**］ボタンを選択して、出力を比較します。
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## ステップ 4: をインストールして設定する AWS SDK for Go
このサンプルを強化して、 AWS SDK for Go を使用して Amazon S3 バケットを作成し、使用可能なバケットを一覧表示してから、先ほど作成したバケットを削除できます。
このステップでは、Go コードから Amazon S3 などの AWS サービスとやり取りする便利な方法 AWS SDK for Goを提供する をインストールして設定します。 AWS SDK for Goをインストールする前に、`GOPATH` 環境変数を設定する必要があります。 AWS SDK for Go インストールして `GOPATH` 環境変数を設定したら、環境で認証情報管理をセットアップする必要があります。が サービスとやり取り AWS するには、これらの認証情報 AWS SDK for Go が必要です。
### GOPATH 環境変数を設定するには
1. 編集する `~/.bashrc` ファイルを開きます。
1. ファイルの最後の行の後に、次のコードを入力します。
```
GOPATH=~/environment/go
export GOPATH
```
1. ファイルを保存します。
1. `~/.bashrc` ファイルをソース化し、ターミナルが今参照した `GOPATH` 環境変数を見つけられるようにします。
```
. ~/.bashrc
```
1. ** `echo $GOPATH` ** コマンドを実行して、`GOPATH` 環境変数が正しく設定されたことを確認します。成功した場合、`/home/ec2-user/environment/go` または `/home/ubuntu/environment/go` が出力されます。
### をインストールするには AWS SDK for Go
AWS SDK for Go ソースの場所を指定して、 ** `go get` ** コマンドを実行します。
```
go get -u github.com/aws/aws-sdk-go/...
```
Go は、`GOPATH`環境変数で指定された場所に AWS SDK for Go ソースをインストールします。これは環境内の`go`フォルダです。
### 環境で認証情報管理を設定するには
を使用して AWS サービスを AWS SDK for Go 呼び出すたびに、呼び出しで一連の認証情報を指定する必要があります。これらの認証情報は、 にその呼び出しを行うための適切なアクセス許可 AWS SDK for Go があるかどうかを決定します。認証情報に適切なアクセス権限がない場合は、呼び出しは失敗します。
このステップでは、環境内に認証情報を保存します。これを行うには、[の環境 AWS のサービス からの呼び出し AWS Cloud9](credentials.md)の手順を実行してから、このトピックに戻ります。
詳細については、*AWS SDK for Go デベロッパーガイド*の「[認証情報の指定](https://docs.aws.amazon.com/sdk-for-go/latest/developer-guide/configuring-sdk.html#specifying-credentials)」を参照してください。
## ステップ 5: AWS SDK コードを追加する
このステップでは、今度は Amazon S3 を操作してバケットを作成し、利用できるバケットのリストを表示した後、作成したバケットを削除するコードをいくつか追加します。このコードは後で実行します。
AWS Cloud9 IDE で、このコンテンツを含むファイルを作成し、 という名前でファイルを保存します`s3.go`。
```
package main
import (
"fmt"
"os"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/s3"
)
func main() {
if len(os.Args) < 3 {
fmt.Printf("Usage: go run s3.go \n" +
"Example: go run s3.go my-test-bucket us-east-2\n")
os.Exit(1)
}
sess := session.Must(session.NewSessionWithOptions(session.Options{
SharedConfigState: session.SharedConfigEnable,
}))
svc := s3.New(sess, &aws.Config{
Region: aws.String(os.Args[2]),
})
listMyBuckets(svc)
createMyBucket(svc, os.Args[1], os.Args[2])
listMyBuckets(svc)
deleteMyBucket(svc, os.Args[1])
listMyBuckets(svc)
}
// List all of your available buckets in this AWS Region.
func listMyBuckets(svc *s3.S3) {
result, err := svc.ListBuckets(nil)
if err != nil {
exitErrorf("Unable to list buckets, %v", err)
}
fmt.Println("My buckets now are:\n")
for _, b := range result.Buckets {
fmt.Printf(aws.StringValue(b.Name) + "\n")
}
fmt.Printf("\n")
}
// Create a bucket in this AWS Region.
func createMyBucket(svc *s3.S3, bucketName string, region string) {
fmt.Printf("\nCreating a new bucket named '" + bucketName + "'...\n\n")
_, err := svc.CreateBucket(&s3.CreateBucketInput{
Bucket: aws.String(bucketName),
CreateBucketConfiguration: &s3.CreateBucketConfiguration{
LocationConstraint: aws.String(region),
},
})
if err != nil {
exitErrorf("Unable to create bucket, %v", err)
}
// Wait until bucket is created before finishing
fmt.Printf("Waiting for bucket %q to be created...\n", bucketName)
err = svc.WaitUntilBucketExists(&s3.HeadBucketInput{
Bucket: aws.String(bucketName),
})
}
// Delete the bucket you just created.
func deleteMyBucket(svc *s3.S3, bucketName string) {
fmt.Printf("\nDeleting the bucket named '" + bucketName + "'...\n\n")
_, err := svc.DeleteBucket(&s3.DeleteBucketInput{
Bucket: aws.String(bucketName),
})
if err != nil {
exitErrorf("Unable to delete bucket, %v", err)
}
// Wait until bucket is deleted before finishing
fmt.Printf("Waiting for bucket %q to be deleted...\n", bucketName)
err = svc.WaitUntilBucketNotExists(&s3.HeadBucketInput{
Bucket: aws.String(bucketName),
})
}
// If there's an error, display it.
func exitErrorf(msg string, args ...interface{}) {
fmt.Fprintf(os.Stderr, msg+"\n", args...)
os.Exit(1)
}
```
## ステップ 6: AWS SDK コードを実行する
1. AWS Cloud9 IDE のメニューバーで、**Run**、**Run Configurations**、**New Run Configuration** を選択します。
1. [**[New] - Idle ([新規] - アイドル)**] タブで、[**Runner: Auto (ランナー: 自動)**] を選択し、[**Go**] を選択します。
1. **コマンドには**、「」と入力します。ここで`s3.go YOUR_BUCKET_NAME THE_AWS_REGION `、 ` YOUR_BUCKET_NAME ` は作成して削除するバケットの名前、 ` THE_AWS_REGION `はバケットを作成する AWS リージョンの ID です。たとえば、米国東部 (オハイオ) リージョンの場合は、`us-east-2` を使用します。他の ID については、[の「](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)Amazon Simple Storage Service (Amazon S3)*Amazon Web Services 全般のリファレンス*」を参照してください。
**注記**
Amazon S3 バケット名は、アカウント AWS だけでなく AWS、 全体で一意である必要があります。
1. ［**実行**］ボタンを選択して、出力を比較します。
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## ステップ 7: クリーンアップする
このサンプルの使用が完了したら、 AWS アカウントへの継続的な課金を防ぐには、環境を削除する必要があります。手順については、「[での環境の削除 AWS Cloud9](delete-environment.md)」を参照してください。
# の TypeScript チュートリアル AWS Cloud9
このチュートリアルでは、 AWS Cloud9 開発環境で TypeScript を使用する方法を示します。
このチュートリアルに従い、このサンプルを作成すると、 AWS アカウントに料金が発生する可能性があります。Amazon EC2 や Amazon S3 などのサービスに対して発生する可能性がある料金も含まれます。詳細については、「[Amazon EC2 料金表](https://aws.amazon.com/ec2/pricing/)」および「[Amazon S3 料金表](https://aws.amazon.com/s3/pricing/)」を参照してください。
**Topics**
+ [前提条件](#sample-typescript-prereqs)
+ [ステップ 1: 必要なツールをインストールする](#sample-typescript-install)
+ [ステップ 2: コードを追加する](#sample-typescript-code)
+ [ステップ 3: コードを実行する](#sample-typescript-run)
+ [ステップ 4: Node.js で AWS SDK for JavaScript をインストールして設定する](#sample-typescript-sdk)
+ [ステップ 5: AWS SDK コードを追加する](#sample-typescript-sdk-code)
+ [ステップ 6: AWS SDK コードを実行する](#sample-typescript-sdk-run)
+ [ステップ 7: クリーンアップする](#sample-typescript-clean-up)
## 前提条件
このサンプルを使用する前に、設定が次の要件を満たしていることを確認します。
+ **既存の AWS Cloud9 EC2 開発環境が必要です。**このサンプルは、Amazon Linux または Ubuntu Server を実行する Amazon EC2 インスタンスに接続された EC2 環境が既にあることを前提としています。別のタイプの環境またはオペレーティングシステムがある場合、このサンプルの指示を関連ツールを設定する必要がある場合があります。詳細については、「[での環境の作成 AWS Cloud9](create-environment.md)」を参照してください。
+ **既存の環境の AWS Cloud9 IDE が既に開いている。**環境を開くと、 はウェブブラウザでその環境の IDE AWS Cloud9 を開きます。詳細については、「[で環境を開く AWS Cloud9](open-environment.md)」を参照してください。
## ステップ 1: 必要なツールをインストールする
このステップでは、Node Package Manager(**`npm`**) を使用して TypeScript をインストールします。**`npm`** をインストールするには、Node Version Manager (**`nvm`**) を使用します。**`nvm`** がない場合は、このステップでインストールします。
1. IDE のターミナルセッションで、 コマンドライン TypeScript AWS Cloud9 コンパイラを **`--version`**オプションで実行してTypeScript が既にインストールされているかどうかを確認します。(新しいターミナルセッションを開始するには、メニューバーで、［**Window (ウィンドウ)**］、［**New Terminal (新しいターミナル)**］の順に選択します。) 成功すると、出力に TypeScript のバージョン番号が表示されます。TypeScript がインストール済みである場合は、[ステップ 2: コードを追加する](#sample-typescript-code) に進みます。
```
tsc --version
```
1. **`--version` **オプションを指定して** `npm` **を実行することにより、**`npm` **が既にインストールされているかどうかを確認します。成功すると、出力に **`npm`** のバージョン番号が表示されます。**`npm`** がインストール済みである場合は、この手順のステップ 10 に進み、**`npm`** を使用して TypeScript をインストールします。
```
npm --version
```
1. ** `yum update` ** (Amazon Linux の場合) または ** `apt update` ** (Ubuntu Server の場合) コマンドを実行して、最新のセキュリティ更新プログラムおよびバグ修正がインストールされていることを確認します。
Amazon Linux の場合:
```
sudo yum -y update
```
Ubuntu Server の場合:
```
sudo apt update
```
1. **`npm` **をインストールするには、まず、次のコマンドを実行して Node Version Manager (**`nvm`**) をダウンロードします(**`nvm` **は、Node.js のバージョンをインストールして管理するために役立つシンプルな Bash シェルスクリプトです。詳細は、GitHub ウェブサイトの [Node Version Manager](https://github.com/creationix/nvm/blob/master/README.md) を参照してください)。
```
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.0/install.sh | bash
```
1. ** `nvm` ** の使用を開始するには、ターミナルセッションを閉じてもう一度起動するか、`~/.bashrc` ** `nvm` をロードするコマンドを含む ** ファイルを入手してください。
```
. ~/.bashrc
```
1. **`--version` **オプションを指定して** `nvm` **を実行することにより、**`nvm` **がインストールされていることを確認します。
```
nvm --version
```
1. 最新のバージョン 16 の Node.js をインストールするには、**`nvm`** コマンドを実行します (**`npm`** は Node.js に含まれています)。
```
nvm install v16
```
1. Node.js がインストール済みであることを確認するために、**`--version`** オプションを指定してコマンドラインバージョンの Node.js を実行します。
```
node --version
```
1. **`--version` **オプションを指定して** `npm` **を実行することにより、**`npm` **がインストールされていることを確認します。
```
npm --version
```
1. ** `-g` ** オプションをで ** `npm` **を実行して、TypeScript ファイルをインストールします。これにより、TypeScript がグローバルパッケージとして 環境にインストールされます。
```
npm install -g typescript
```
1. **`--version`** オプションを指定してコマンドライン TypeScript コンパイラーを実行し、TypeScript がインストール済みであることを確認します。
```
tsc --version
```
## ステップ 2: コードを追加する
1. AWS Cloud9 IDE で、 という名前のファイルを作成します`hello.ts`。(メニューバーでファイルを作成するには、**ファイル**、**New File (新しいファイル)**を選択します。 ファイルを保存するには、**ファイル**、**保存**を選択します。)
1. IDE のターミナルで、`hello.ts` ファイルと同じディレクトリから ** `npm` ** を実行して `@types/node` ライブラリをインストールします。
```
npm install @types/node
```
これにより、`node_modules/@types/node` ファイルと同じディレクトリに `hello.ts` フォルダが追加されます。この新しいフォルダには、Node.js の型定義が入ります。これらの定義は、この手順の後半で `hello.ts` ファイルに追加する `console.log` プロパティと `process.argv` プロパティで使用するために TypeScript で必要になります。
1. 次のコードを `hello.ts` ファイルに追加します。
```
console.log('Hello, World!');
console.log('The sum of 2 and 3 is 5.');
const sum: number = parseInt(process.argv[2], 10) + parseInt(process.argv[3], 10);
console.log('The sum of ' + process.argv[2] + ' and ' +
process.argv[3] + ' is ' + sum + '.');
```
## ステップ 3: コードを実行する
1. ターミナルで、`hello.ts` ファイルと同じディレクトリから TypeScript コンパイラーを実行します。含める `hello.ts` ファイルと追加のライブラリを指定します。
```
tsc hello.ts --lib es6
```
TypeScript は、`hello.ts` ファイルと一連の ECMAScript 6 (ES6) ライブラリファイルを使用して、`hello.ts` ファイル内の TypeScript コードを、`hello.js` というファイル内の同等の JavaScript コードに変換します。
1. [**Environment (環境)**] ウィンドウで、`hello.js` ファイルを開きます。
1. メニューバーで、［**Run (実行)**］、［**Run Configurations (実行設定)**］、［**New Run Configuration (新しい実行設定)**］の順に選択します。
1. ［**［New] - Id］e (［新規] - アイドル)**] タブで、［**Runner: Auto (ランナー: 自動)**] を選択し、［**Node.js**] を選択します。
1. ［**Command (コマンド)**] に「`hello.js 5 9`」と入力します。このコードで、`5` は `process.argv[2]` を表し、`9` は `process.argv[3]` を表します (`process.argv[0]` はランタイム (`node`) の名前、`process.argv[1]` はファイル (`hello.js`) の名前です)。
1. [**Run (実行)**] を選択して、出力を比較します。完了したら、[**Stop (停止)**] を選択します。
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
![\[IDE でコードを実行した後の Node.js AWS Cloud9 出力\]](http://docs.aws.amazon.com/ja_jp/cloud9/latest/user-guide/images/ide-nodejs-simple.png)
**注記**
IDE で新しい実行構成を作成する代わりに、ターミナルからコマンド **`node hello.js 5 9`** を実行してこのコードを実行することもできます。
## ステップ 4: Node.js で AWS SDK for JavaScript をインストールして設定する
このサンプルを強化して、Node.js で AWS SDK for JavaScript を使用して Amazon S3 バケットを作成し、使用可能なバケットを一覧表示してから、先ほど作成したバケットを削除できます。
このステップでは、 AWS SDK for JavaScript を Node.js にインストールして設定します。SDK は、JavaScript コードから Amazon S3 などの AWS サービスとやり取りする便利な方法を提供します。Node.js に AWS SDK for JavaScript をインストールしたら、 環境で認証情報管理を設定する必要があります。SDK が AWS サービスとやり取りするには、これらの認証情報が必要です。
### Node.js に AWS SDK for JavaScript をインストールするには
AWS Cloud9 IDE のターミナルセッションで、 の `hello.js` ファイルと同じディレクトリから[ステップ 3: コードを実行する](#sample-typescript-run)、 ** `npm` ** を実行して AWS SDK for JavaScript を Node.js にインストールします。
```
npm install aws-sdk
```
このコマンドは、[ステップ 3: コードを実行する](#sample-typescript-run) から`node_modules` フォルダにいくつかのフォルダを追加します。これらのフォルダには、Node.js の AWS SDK for JavaScript のソースコードと依存関係が含まれています。詳細については、*AWS SDK for JavaScript デベロッパーガイド*の「[SDK for JavaScript のインストール](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/installing-jssdk.html)」を参照してください。
### 環境で認証情報管理を設定するには
Node.js で AWS SDK for JavaScript を使用して AWS サービスを呼び出すたびに、呼び出しで一連の認証情報を指定する必要があります。これらの認証情報は、Node.js の AWS SDK for JavaScript にその呼び出しを行うための適切なアクセス許可があるかどうかを決定します。認証情報に適切なアクセス権限がない場合は、呼び出しは失敗します。
このステップでは、環境内に認証情報を保存します。これを行うには、[の環境 AWS のサービス からの呼び出し AWS Cloud9](credentials.md) の手順を実行してから、このトピックに戻ります。
詳細については、*AWS SDK for JavaScript デベロッパーガイド*の「[Setting Credentials in Node.js (Noda.jp に認証情報を設定)](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html)」を参照してください。
## ステップ 5: AWS SDK コードを追加する
このステップでは、今度は Amazon S3 を操作してバケットを作成し、利用できるバケットのリストを表示した後、作成したバケットを削除するコードをいくつか追加します。このコードは後で実行します。
1. AWS Cloud9 IDE で、前のステップの `hello.js` ファイルと同じディレクトリに、 という名前のファイルを作成します`s3.ts`。
1. AWS Cloud9 IDE のターミナルから、 `s3.ts` ファイルと同じディレクトリで、コードを 2 **`npm`**回実行して TypeScript 用の非同期ライブラリをインストールし、JavaScript 用の非同期ライブラリを再度インストールすることで、Amazon S3 オペレーションを非同期的に呼び出すことができます。
```
npm install @types/async # For TypeScript.
npm install async # For JavaScript.
```
1. 次のコードを `s3.ts` ファイルに追加します。
```
import * as async from 'async';
import * as AWS from 'aws-sdk';
if (process.argv.length < 4) {
console.log('Usage: node s3.js \n' +
'Example: node s3.js my-test-bucket us-east-2');
process.exit(1);
}
const AWS = require('aws-sdk'); // To set the AWS credentials and AWS Region.
const async = require('async'); // To call AWS operations asynchronously.
const s3: AWS.S3 = new AWS.S3({apiVersion: '2006-03-01'});
const bucket_name: string = process.argv[2];
const region: string = process.argv[3];
AWS.config.update({
region: region
});
const create_bucket_params: any = {
Bucket: bucket_name,
CreateBucketConfiguration: {
LocationConstraint: region
}
};
const delete_bucket_params: any = {
Bucket: bucket_name
};
// List all of your available buckets in this AWS Region.
function listMyBuckets(callback): void {
s3.listBuckets(function(err, data) {
if (err) {
} else {
console.log("My buckets now are:\n");
for (let i: number = 0; i < data.Buckets.length; i++) {
console.log(data.Buckets[i].Name);
}
}
callback(err);
});
}
// Create a bucket in this AWS Region.
function createMyBucket(callback): void {
console.log("\nCreating a bucket named '" + bucket_name + "'...\n");
s3.createBucket(create_bucket_params, function(err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Delete the bucket you just created.
function deleteMyBucket(callback): void {
console.log("\nDeleting the bucket named '" + bucket_name + "'...\n");
s3.deleteBucket(delete_bucket_params, function(err, data) {
if (err) {
console.log(err.code + ": " + err.message);
}
callback(err);
});
}
// Call the AWS operations in the following order.
async.series([
listMyBuckets,
createMyBucket,
listMyBuckets,
deleteMyBucket,
listMyBuckets
]);
```
## ステップ 6: AWS SDK コードを実行する
1. ターミナルで、`s3.ts` ファイルと同じディレクトリから TypeScript コンパイラーを実行します。含める `s3.ts` ファイルと追加のライブラリを指定します。
```
tsc s3.ts --lib es6
```
TypeScript は、 `s3.ts` ファイル、Node.js の AWS SDK for JavaScript、非同期ライブラリ、および一連の ECMAScript 6 (ES6) ライブラリファイルを使用して、 `s3.ts` ファイル内の TypeScript コードを という名前のファイル内の同等の JavaScript コードに変換します`s3.js`。
1. [**Environment (環境)**] ウィンドウで、`s3.js` ファイルを開きます。
1. メニューバーで、［**Run (実行)**］、［**Run Configurations (実行設定)**］、［**New Run Configuration (新しい実行設定)**］の順に選択します。
1. ［**［New] - Id］e (［新規] - アイドル)**] タブで、［**Runner: Auto (ランナー: 自動)**] を選択し、［**Node.js**] を選択します。
1. **コマンドには**、「」と入力します。ここで`s3.js YOUR_BUCKET_NAME THE_AWS_REGION `、 ` YOUR_BUCKET_NAME ` は作成して削除するバケットの名前、 ` THE_AWS_REGION `はバケットを作成する AWS リージョンの ID です。たとえば、米国東部 (オハイオ) リージョンの場合は、`us-east-2` を使用します。他の ID については、[の「](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region)Amazon Simple Storage Service (Amazon S3)*Amazon Web Services 全般のリファレンス*」を参照してください。
**注記**
Amazon S3 バケット名は、アカウント AWS だけでなく AWS、 全体で一意である必要があります。
1. [**Run (実行)**] を選択して、出力を比較します。完了したら、[**Stop (停止)**] を選択します。
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## ステップ 7: クリーンアップする
このサンプルの使用が完了したら、 AWS アカウントへの継続的な課金を防ぐには、環境を削除する必要があります。手順については、「[での環境の削除 AWS Cloud9](delete-environment.md)」を参照してください。
# の Docker チュートリアル AWS Cloud9
このチュートリアルでは、Amazon EC2 AWS Cloud9 の Amazon Linux インスタンス内で実行中の Docker コンテナに SSH 開発環境を接続する方法を示します。これにより、IDE AWS Cloud9 を使用して Docker コンテナ内のコードとファイルを操作し、そのコンテナでコマンドを実行できます。Docker の詳細については、Docker ウェブサイトの「[Docker とは](https://www.docker.com/what-docker)」を参照してください。
このチュートリアルに従い、このサンプルを作成すると、 AWS アカウントに料金が発生する可能性があります。Amazon EC2 などのサービスに対して発生する可能性がある料金も含まれます。詳細については、「[Amazon EC2 の料金](https://aws.amazon.com/ec2/pricing/)」を参照してください。
**Topics**
+ [前提条件](#sample-docker-prereqs)
+ [ステップ 1: Docker のインストールと実行](#sample-docker-install)
+ [ステップ 2: イメージの構築](#sample-docker-build)
+ [ステップ 3: コンテナの実行](#sample-docker-run)
+ [ステップ 4: 環境の作成](#sample-docker-env)
+ [ステップ 5: コードの実行](#sample-docker-code)
+ [ステップ 6: クリーンアップする](#sample-docker-clean-up)
## 前提条件
+ **Amazon Linux または Ubuntu Server を実行している Amazon EC2 インスタンスを用意する必要があります。**このサンプルは、 AWS アカウントに Amazon Linux または Ubuntu Server を実行している Amazon EC2 インスタンスが既にあることを前提としています。Amazon EC2 インスタンスを起動するには、「[Linux 仮想マシンの起動](https://aws.amazon.com/getting-started/tutorials/launch-a-virtual-machine/)」を参照してください。ウィザードの 「**Amazon マシンイメージ (AMI) の選択**」ページで、表示名が **Amazon Linux AMI** または **Ubuntu Server** で始まる AMI を選択します。
+ **Amazon EC2 インスタンスを Amazon VPC 内で実行する場合は、追加の要件があります。**「[AWS Cloud9 開発環境の VPC 設定](vpc-settings.md)」を参照してください。
+ **Amazon EC2 インスタンスには、少なくとも 8〜16 GB の利用可能な空きディスク容量が必要です。**このサンプルでは、3 GB 以上のサイズの Docker イメージを使用し、イメージ構築のためにさらに 3 GB 以上のディスク空き容量を使用することがあります。8 GB 以下の空き容量のディスクでこのサンプルの実行を試行すると、Docker イメージが構築されない、あるいは Docker コンテナが実行されない結果となる場合があります。インスタンスの空きディスク容量を確認するには、インスタンスで **`df -h`** (「人間が読める形式のディスクファイルシステム情報」) などのコマンドを実行します。既存のインスタンスのディスクサイズを増やすには、*Amazon EC2 ユーザーガイド*の「[ボリュームの変更](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-modify-volume.html)」を参照します。
## ステップ 1: Docker のインストールと実行
このステップでは、Docker が Amazon EC2 インスタンスにインストールされているかをチェックし、まだインストールされていない場合は Docker をインストールします。Docker をインストールしたら、インスタンスでこれを実行します。
1. ** `ssh` ** ユーティリティまたは PuTTY など、SSH クライアントを使って、実行中の Amazon EC2 インスタンスに接続します。これを行うには、「[Linux 仮想マシンを起動する](https://aws.amazon.com/getting-started/tutorials/launch-a-virtual-machine/)」の「ステップ 3: インスタンスに接続する」を参照してください。
1. Docker がインスタンスにインストールされているかを確認します。これを行うには、**`docker`** オプションを使用して **`--version`** コマンドをインスタンスで実行します。
```
docker --version
```
Docker がインストールされている場合、Docker バージョンおよびビルド番号が表示されます。この場合、この手順の先のステップ 5 に進みます。
1. Docker をインストールします。これを行うには、**`yum` **または** `apt` **コマンドを** `install` **アクションを指定して実行し、インストールする** `docker` **または** `docker.io` **パッケージを指定します。
Amazon Linux の場合:
```
sudo yum install -y docker
```
Ubuntu Server の場合:
```
sudo apt install -y docker.io
```
1. Docker がインストールされていることを確認します。これを行うには、**`docker --version`** コマンドを再度実行します。Docker バージョンおよびビルド番号が表示されます。
1. Docker を実行します。これを行うには、**`docker` **サービスおよび** `start` **アクションを指定して、**`service` **コマンドを実行します。
```
sudo service docker start
```
1. Docker が実行されていることを確認します。これを行うには、**`docker`** アクションで **`info`** コマンドを実行します。
```
sudo docker info
```
Docker が実行されている場合、Docker についての情報が表示されます。
## ステップ 2: イメージの構築
このステップでは、Dockerfile を使用してインスタンスに Docker イメージを構築します。このサンプルでは、Node.js が含まれるイメージおよびサンプルチャートサーバーアプリケーションを使用します。
1. インスタンスで Dockerfile を作成します。これを行うには、SSH クライアントをインスタンスに接続した状態で、インスタンスの `/tmp` ディレクトリ内に `Dockerfile` という名前のファイルを作成します。例えば、次のように **`touch`** コマンドを実行します。
```
sudo touch /tmp/Dockerfile
```
1. `Dockerfile` ファイルに次の内容を追加します。
```
# Build a Docker image based on the Amazon Linux 2 Docker image.
FROM amazonlinux:2
# install common tools
RUN yum install -y https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
RUN yum update -y
RUN yum install -y sudo bash curl wget git man-db nano vim bash-completion tmux gcc gcc-c++ make tar
# Enable the Docker container to communicate with AWS Cloud9 by
# installing SSH.
RUN yum install -y openssh-server
# Ensure that Node.js is installed.
RUN yum install -y nodejs
# Create user and enable root access
RUN useradd --uid 1000 --shell /bin/bash -m --home-dir /home/ubuntu ubuntu && \
sed -i 's/%wheel\s.*/%wheel ALL=NOPASSWD:ALL/' /etc/sudoers && \
usermod -a -G wheel ubuntu
# Add the AWS Cloud9 SSH public key to the Docker container.
# This assumes a file named authorized_keys containing the
# AWS Cloud9 SSH public key already exists in the same
# directory as the Dockerfile.
RUN mkdir -p /home/ubuntu/.ssh
ADD ./authorized_keys /home/ubuntu/.ssh/authorized_keys
RUN chown -R ubuntu /home/ubuntu/.ssh /home/ubuntu/.ssh/authorized_keys && \
chmod 700 /home/ubuntu/.ssh && \
chmod 600 /home/ubuntu/.ssh/authorized_keys
# Update the password to a random one for the user ubuntu.
RUN echo "ubuntu:$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 32 | head -n 1)" | chpasswd
# pre-install Cloud9 dependencies
USER ubuntu
RUN curl https://d2j6vhu5uywtq3.cloudfront.net/static/c9-install.sh | bash
USER root
# Start SSH in the Docker container.
CMD ssh-keygen -A && /usr/sbin/sshd -D
```
上のコンテンツを `Dockerfile` ファイルに追加するには、次のようにインスタンスで **`vi`** ユーティリティを使用できます。
1. を使用して`/tmp/Dockerfile`、 ファイル AWS Cloud9 を開いて編集します。
```
sudo vi /tmp/Dockerfile
```
1. `Dockerfile` ファイルに前述のコンテンツをを貼り付けます。方法がわからない場合は、SSH クライアントのドキュメントを参照してください。
1. コマンドモードに切り替えます。これを行うには `Esc` キーを押します (ウィンドウの下部から `-- INSERT --` が消えます)。
1. `:wq` と入力します (`/tmp/Dockerfile` ファイルに書き込み、このファイルを保存し、**`vi`** を終了します)。次に、`Enter` を押します。
**注記**
Docker イメージの頻繁に更新されるリストには、 からアクセスできます AWS CodeBuild。詳細については、AWS CodeBuild ユーザーガイドで 「[CodeBuild が提供する Docker イメージ](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-available.html)」を参照してください。
1. インスタンスで、Docker コンテナが使用する AWS Cloud9 SSH パブリックキーを含むファイルを作成します。これを行うには、**`touch`** コマンドを実行して、`Dockerfile` ファイルと同じディレクトリ内に `authorized_keys` のような名前のファイルを作成します。
```
sudo touch /tmp/authorized_keys
```
1. SSH AWS Cloud9 パブリックキーを `authorized_keys` ファイルに追加します。SSH AWS Cloud9 パブリックキーを取得するには、次の手順を実行します。
1. [https://console.aws.amazon.com/cloud9/](https://console.aws.amazon.com/cloud9/) で AWS Cloud9 コンソールを開きます。
1. AWS ナビゲーションバーの AWS リージョンセレクターで、このトピックの後半で AWS Cloud9 開発環境を作成する AWS リージョンを選択します。
1. ようこそページが表示された場合は、**新しい AWS Cloud9 環境** で環境**の作成** を選択します。それ以外の場合は、［**Create environment (環境の作成)**］を選択します。
1. ［**Name environment (環境に名前を付ける)**］ページで、［**名前**］には、環境の名前を入力します。(ここでは、名前は重要ではありません。 後で別の名前を選択できます。)
1. ［**Next step**］を選択します。
1. ［**Environment type (環境タイプ)**］で［**Connect and run in remote server (SSH) (リモートサーバーに接続して実行する)**］を選択します。
1. ［**View public SSH key (パブリック SSH キーを表示)**］を展開します。
1. ［**Copy key to clipboard (キーをクリップボードにコピー)**］を選択します (これは［**View public SSH key (パブリック SSH キーの表示)**］と［**Advanced settings (詳細設定)**］の間になります)。
1. **[キャンセル]** を選択します。
1. クリップボードのコンテンツを `authorized_keys` ファイルに貼り付け、このファイルを保存します。例えば、このステップで前に説明したように、**`vi`** ユーティリティを使用できます。
1. **`docker` **コマンドを** `build` **アクションを指定して実行し、タグ `cloud9-image:latest` をイメージに追加し、使用する `Dockerfile` ファイルへのパスを指定してイメージをビルドします。
```
sudo docker build -t cloud9-image:latest /tmp
```
成功すると、構築出力の最後の 2 行には `Successfully built` および `Successfully tagged` が表示されます。
Docker でイメージが正しく構築されたことを確かめるには、**`docker`** コマンドに `image ls` アクションを指定して実行します。
```
sudo docker image ls
```
成功した場合には、出力の `REPOSITORY` フィールドが `cloud9-image`、`TAG` フィールドが `latest` に設定されたエントリが表示されます。
1. Amazon EC2 インスタンスのパブリック IP アドレスをメモしておきます。これは [ステップ 4: 環境の作成](#sample-docker-env) で必要になります。インスタンスのパブリック IP アドレスがわからない場合は、インスタンスで次のコマンドを実行してそれを取得します。
```
curl http://169.254.169.254/latest/meta-data/public-ipv4
```
## ステップ 3: コンテナの実行
このステップでは、インスタンスで Docker コンテナを実行します。このコンテナは前のステップで構築したイメージに基づいています。
1. Docker コンテナを実行するには、インスタンスで **`run`** アクションと以下のオプションを指定して **`docker`** コマンドを実行します。
```
sudo docker run -d -it --expose 9090 -p 0.0.0.0:9090:22 --name cloud9 cloud9-image:latest
```
+ `-d` は、コンテナを実行していたルートプロセス (このサンプルでは、SSH クライアント) を終了して、デタッチ済みモードでコンテナを実行します。
+ `-it` は、割り当てられた疑似 TTY でコンテナを実行し、コンテナがアタッチされていない場合でも STDIN をオープンのままにします。
+ `--expose` は、コンテナに対して特定のポート (このサンプルでは、ポート `9090`) を利用可能にします。
+ `-p` は、指定された IP アドレスとポートを介して特定のポートを Amazon EC2 インスタンスの内部で利用できるようにします。このサンプルでは、コンテナのポート `9090` は、Amazon EC2 インスタンスのポート `22` を介して内部からアクセスできます。
+ `--name` は、このコンテナの人間が読み取れる名前です (このサンプルでは、`cloud9`)。
+ `cloud9-image:latest` は、コンテナを実行するために使用するビルドイメージの人間が読み取れる名前です。
Docker がコンテナを正しく実行していることを確かめるには、**`docker`** コマンドに `container ls` アクションを指定して実行します。
```
sudo docker container ls
```
成功した場合には、出力の `IMAGE` フィールドが `cloud9-image:latest`、`NAMES` フィールドが `cloud9` に設定されたエントリが表示されます。
1. 実行中のコンテナにログインします。これを行うには、**`exec`** アクションと以下のオプションを指定して **`docker`** コマンドを実行します。
```
sudo docker exec -it cloud9 bash
```
+ `-it` は、割り当てられた疑似 TTY でコンテナを実行し、コンテナがアタッチされていない場合でも STDIN をオープンのままにします。
+ `cloud9` は、実行中のコンテナの人間が読み取れる名前です。
+ `bash` は、実行中のコンテナで標準のシェルを起動します。
成功した場合、ターミナルプロンプトはログインしたユーザー名をコンテナとコンテナの ID に変更します。
**注記**
実行中のコンテナからログアウトする場合は、**`exit`** コマンドを実行します。ターミナルプロンプトはログインしたユーザー名をインスタンスとこのインスタンスのプライベート DNS に再度変更します。コンテナは実行中である必要があります。
1. ログイン後に AWS Cloud9 開始する実行中のコンテナのディレクトリについては、そのアクセス許可を ** `rwxr-xr-x` **に設定します。これは、所有者には読み取り/書き込み/実行のアクセス許可、グループには読み取り/実行のアクセス許可、その他には読み取り/実行のアクセス許可があることを意味します。例えば、ディレクトリのパスが `~` である場合、実行中のコンテナで **`chmod`** コマンドを次のように実行して、ディレクトリにこれらのアクセス許可を設定できます。
```
sudo chmod u=rwx,g=rx,o=rx ~
```
1. [ステップ 4: 環境の作成](#sample-docker-env) で必要となるため、Node.js バイナリを含む実行中のコンテナのディレクトリのパスをメモしておきます。このパスがわからない場合は、実行中のコンテナで次のコマンドを実行してこれを取得します。
```
which node
```
## ステップ 4: 環境の作成
このステップでは、 AWS Cloud9 を使用して SSH AWS Cloud9 開発環境を作成し、実行中の Docker コンテナに接続します。が環境 AWS Cloud9 を作成すると、IDE AWS Cloud9 が表示され、コンテナ内のファイルとコードの操作を開始できます。
AWS Cloud9 コンソールを使用して SSH AWS Cloud9 開発環境を作成します。CLI を使用して SSH 環境を作成することはできません。
### 前提条件
+ まず、「[セットアップ AWS Cloud9](setting-up.md)」のステップを完了していることを確認します。これにより、 AWS Cloud9 コンソールにサインインして環境を作成できます。
+ 環境 AWS Cloud9 に接続する既存のクラウドコンピューティングインスタンス ( の Amazon EC2 インスタンスなど AWS アカウント) または独自のサーバーを特定します。
+ 既存のインスタンスまたは独自のサーバーが、すべての [SSH ホスト要件](ssh-settings.md#ssh-settings-requirements)を満たしていることを確認します。これには、特定のバージョンの Python、Node.js、およびその他のコンポーネントをインストールしていること、ログイン後に AWS Cloud9 をスタートしたいディレクトリに具体的なの許可を設定していること、関連した Amazon Virtual Private Cloud を設定していることなどが含まれます。
### SSH 環境を作成する
1. 前述の前提条件を完了していることを確認してください。
1. SSH クライアントを使用して既存のインスタンスまたは独自のサーバーに接続します (まだ接続していない場合)。これにより、インスタンスまたはサーバーに必要な公開 SSH キー値を追加できます。詳細については、この手順で後ほど説明します。
**注記**
既存の AWS クラウド コンピューティングインスタンスに接続するには、次の 1 つ以上のリソースを参照してください。
Amazon EC2 については、「*Amazon EC2 ユーザーガイド」*の「[Linux インスタンスに接続](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html)」を参照してください。
Amazon Lightsail については、*Amazon Lightsail ドキュメント*の「[Linux/UNIX ベースの Lightsail インスタンスへの接続](https://lightsail.aws.amazon.com/ls/docs/how-to/article/lightsail-how-to-connect-to-your-instance-virtual-private-server)」を参照してください。
については AWS Elastic Beanstalk、「 *AWS Elastic Beanstalk デベロッパーガイド*[」の「サーバーインスタンスの一覧表示と接続](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/using-features.ec2connect.html)」を参照してください。
については AWS OpsWorks、「 *AWS OpsWorks ユーザーガイド*」の[「SSH を使用して Linux インスタンスにログインする](https://docs.aws.amazon.com/opsworks/latest/userguide/workinginstances-ssh.html)」を参照してください。
その他の方法については AWS のサービス、その特定のサービスのドキュメントを参照してください。
独自のサーバーに接続するには、SSH を使用します。SSH は macOS および Linux オペレーティングシステムに既にインストールされています。Windows で SSH を使用してサーバーに接続するには、[PuTTY](https://www.putty.org/) をインストールする必要があります。
1. [https://console.aws.amazon.com/cloud9/](https://console.aws.amazon.com/cloud9/) で AWS Cloud9 コンソールにサインインします。
1. AWS Cloud9 コンソールにサインインしたら、上部のナビゲーションバーで AWS リージョン を選択して環境を作成します。利用可能な のリストについては AWS リージョン、 [AWS Cloud9](https://docs.aws.amazon.com/general/latest/gr/rande.html#cloud9_region) の「」を参照してください*AWS 全般のリファレンス*。
![\[AWS Cloud9 コンソールのリージョンセレクター\]](http://docs.aws.amazon.com/ja_jp/cloud9/latest/user-guide/images/consolas_region_new_UX.png)
1. 今回、開発環境を初めて作成する場合は、ウェルカムページが表示されます。**新しい AWS Cloud9 環境**パネルで、**環境の作成**を選択します。
以前に開発環境を作成したことがある場合は、画面の左側にあるペインを展開することもできます。**[Your environments]** (自分の環境)、**[Create environment]** (環境の作成) の順に選択します。
**ウェルカム**ページの場合:
![\[ウェルカムページが表示された場合は、［Create environment] (環境の作成) ボタンを選択します\]](http://docs.aws.amazon.com/ja_jp/cloud9/latest/user-guide/images/create_welcome_env_new_UX.png)
または、**[Your environments]** (自分の環境) ページの場合:
![\[ウェルカムページが表示されない場合は、［Create environment] (環境の作成) ボタンを選択します\]](http://docs.aws.amazon.com/ja_jp/cloud9/latest/user-guide/images/console_create_env_new_UX.png)
1. **[Create environment]** (環境の作成) ページで、環境の名前を入力します。
1. ［**Description (説明)**］に、環境に関する説明を入力します。このチュートリアルでは、`This environment is for the AWS Cloud9 tutorial.` を使用します。
1. **[Environment type]** (環境タイプ) で、以下のオプションから **[Existing Compute]** (既存のコンピューティング) を選択します。
+ **新しい EC2 インスタンス** – SSH 経由で に直接接続 AWS Cloud9 できる Amazon EC2 インスタンスを起動します。
+ ** 既存のコンピューティング ** – 開いているインバウンドポートを必要としない Amazon EC2 インスタンスを起動します。 は を介してインスタンス AWS Cloud9 に接続します[AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager.html)。
+ **[Existing compute]** (既存のコンピューティング) オプションを選択すると、Systems Manager がユーザーに代わって EC2 インスタンスとやり取りすることを許可するためのサービスロールと IAM インスタンスプロファイルが作成されます。両方の名前は、インターフェイスの下方にある [**Systems Manager アクセス用のサービスロールとインスタンスプロファイル**] セクションで確認できます。詳細については、「[を使用した no-ingress EC2 インスタンスへのアクセス AWS Systems Manager](ec2-ssm.md)」を参照してください。
**警告**
環境に EC2 インスタンスを作成すると、Amazon EC2 AWS アカウント の に料金が発生する可能性があります。Systems Manager を使用して EC2 インスタンスへの接続を管理する場合、追加コストはかかりません。
**警告**
AWS Cloud9 は SSH パブリックキーを使用してサーバーに安全に接続します。安全な接続を確立するには、以下の手順に従って公開キーを `~/.ssh/authorized_keys` ファイルに追加し、ログイン認証情報を入力します。**[Copy key to clipboard]** (キーをクリップボードにコピー) を選択して SSH キーをコピーするか、**[View public SSH key]** (SSH 公開キーを表示) を選択してキーを表示します。
1. **[Existing compute]** (既存のコンピューティング) パネルの **[User]** (ユーザー) に、この手順で先にインスタンスまたはサーバーに接続するときに使用したログイン名を入力します。例えば、 AWS クラウド コンピューティングインスタンスの場合は、`ec2-user`、`ubuntu`、または `root` を入力します。
**注記**
ログイン名をインスタンスやサーバーの管理者アクセス許可または管理者ユーザーに関連付けることをお勧めします。より具体的には、このログイン名がインスタンスやサーバーの Node.js インストールの所有者であることが推奨されます。これをチェックするには、インスタンスやサーバーのターミナルから、** `ls -l $(which node)` ** (または `nvm` を使用している場合は ** `ls -l $(nvm which node)` **) コマンドを実行します。このコマンドは、Node.js インストールの所有者名を表示します。また、インストールのアクセス許可、グループ名、場所も表示されます。
1. **[Host]** (ホスト) に、インスタンスまたはサーバーのパブリック IP アドレス (優先) またはホスト名を入力します。
1. **ポート**には、インスタンスまたはサーバーへの接続を試みる AWS Cloud9 ポートを入力します。または、デフォルトのポートをそのまま使用します。
1. **[Additional details - optional]** (その他の詳細 - オプション) を選択し、環境パス、node.js バイナリへのパス、SSH ジャンプホスト情報を表示します。
1. **環境パス**には、 AWS Cloud9 開始するインスタンスまたはサーバーのディレクトリへのパスを入力します。この手順の前提条件で、以前、これを確認しました。空白のままにすると、 AWS Cloud9 はログイン後に通常インスタンスまたはサーバーを起動するディレクトリを使用します。これは通常、ホームまたはデフォルトのディレクトリです。
1. **[Path to Node.js binary]** (Node.js バイナリへのパス) にパス情報を入力し、インスタンスまたはサーバーの Node.js バイナリへのパスを指定します。パスを取得するには、インスタンスまたはサーバーでコマンド **`which node`** (`nvm` を使用している場合は **`nvm which node`**) を実行できます。例えば、パスは `/usr/bin/node` のようになります。空白のままにした場合、 AWS Cloud9 は接続の試行時に Node.js バイナリの場所の推測を試みます。
1. **[SSH jump host]** (SSH ジャンプホスト) に、インスタンスまたはサーバーが使用するジャンプホストに関する情報を入力します。`USER_NAME@HOSTNAME:PORT_NUMBER` 形式を使用します (例: `ec2-user@:ip-192-0-2-0:22`)。
ジャンプホストは、以下の要件を満たしている必要があります。
+ SSH を使用してパブリックインターネット経由で到達可能とする必要があります。
+ 特定のポートを経由したすべての IP アドレスからのインバウンドアクセスを許可する必要があります。
+ 既存のインスタンスまたはサーバーの `~/.ssh/authorized_keys` ファイルにコピーしたパブリック SSH キー値を、ジャンプホストの `~/.ssh/authorized_keys` ファイルにもコピーする必要があります。
+ Netcat をインストールする必要があります。
1. 最大 50 個のタグを追加します。タグごとに**キー**と**値**を指定します。これを行うには、**[Add new tag]** (新しいタグを追加) を選択します。タグはリソースタグとして AWS Cloud9 環境にアタッチされ、 CloudFormation スタック、Amazon EC2 インスタンス、Amazon EC2 セキュリティグループの基盤となるリソースに伝達されます。タグの詳細については、*[IAM ユーザーガイド](https://docs.aws.amazon.com/IAM/latest/UserGuide/)*の[AWS 「リソースタグを使用したアクセスの制御](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html)」およびこのガイドのタグに関する詳細[情報](tags.md)を参照してください。
**警告**
これらのタグを作成後に更新した場合、変更は基になるリソースには反映されません。詳細については、[タグ](tags.md)に関する詳細情報の「[基礎となるリソースへのタグ更新の伝播](tags.md#tags-propagate)」を参照してください。
1. **[Create]** (作成) を選択して環境を作成すると、ホームページにリダイレクトされます。アカウントが正常に作成されると、 AWS Cloud9 コンソールの上部に緑色のフラッシュバーが表示されます。新しい環境を選択し、**[Open in Cloud9]** (Cloud9 で開く) を選択して IDE を起動できます。
![\[AWS Cloud9 AWS Cloud9 コンソールの IDE セレクター\]](http://docs.aws.amazon.com/ja_jp/cloud9/latest/user-guide/images/cloud9-ide-open.png)
アカウントの作成に失敗すると、 AWS Cloud9 コンソールの上部に赤い点滅バーが表示されます。ウェブブラウザ、 AWS アクセス許可、インスタンス、または関連するネットワークに問題があるため、アカウントの作成に失敗することがあります。アカウントが失敗する原因と考えられる問題の可能な解決方法については、「[AWS Cloud9 のトラブルシューティング](troubleshooting.md#troubleshooting-env-loading)」セクションを参照してください。
**注記**
環境でプロキシを使用してインターネットにアクセスしている場合は、依存関係をインストール AWS Cloud9 できるようにプロキシの詳細を に提供する必要があります。詳細については、「[依存関係をインストールできませんでした](troubleshooting.md#proxy-failed-dependencies)」を参照してください。
## ステップ 5: コードの実行
このステップでは、IDE AWS Cloud9 を使用して、実行中の Docker コンテナ内でサンプルアプリケーションを実行します。
1. 実行中のコンテナの IDE AWS Cloud9 が表示されたら、サンプルチャットサーバーを起動します。これを行うには、［**Environment (環境)**］ウィンドウで、サンプル `workspace/server.js` ファイルを右クリックし、［**Run (実行)**］を選択します。
1. サンプルアプリケーションをプレビューします。これを行うには、［**Environment (環境)**］ウィンドウで `workspace/client/index.html` ファイルを開きます。次に、メニューバーで［**Tools (ツール)、［Preview (プレビュー)］、［Preview Running Application (実行中のアプリケーションのプレビュー)］**の順に選択します。
1. アプリケーションのプレビュータブで、［**Your Name (あなたの名前)**］に名前を入力します。［**Message (メッセージ)**］にメッセージを入力します。次に、［**Send (送信)**］を選択します。チャットサーバーは、ユーザーの名前とメッセージをリストに追加します。
## ステップ 6: クリーンアップする
このステップでは、環境を削除し、Amazon EC2 インスタンスから AWS Cloud9 および Docker サポートファイルを削除します。また、このサンプルの使用が終了した後に AWS アカウントへの継続的な料金が発生しないようにするには、Docker を実行している Amazon EC2 インスタンスを終了する必要があります。
### ステップ 6.1: 環境を削除する
環境を削除するには、[での環境の削除 AWS Cloud9](delete-environment.md) を参照します。
### ステップ 6.2: コンテナから AWS Cloud9 サポートファイルを削除する
環境を削除した後も、一部の AWS Cloud9 サポートファイルはコンテナに残ります。コンテナを引き続き使用したいが、これらのサポートファイルが不要になった場合は、ログイン後に開始 AWS Cloud9 するように指定したコンテナのディレクトリから `.c9`フォルダを削除します。例えば、ディレクトリが `~` の場合、以下のように** `-r` **オプションを使用して** `rm` **コマンドを実行します。
```
sudo rm -r ~/.c9
```
### ステップ 6.3: インスタンスから Docker サポートファイルを削除する
Docker コンテナ、Docker イメージ、および Amazon EC2 インスタンス上の Docker を保持したいと思わなくなりましたが、インスタンスは維持したい場合には、次のように Docker サポートファイルを削除できます。
1. インスタンスから Docker コンテナを削除します。これを行うには、インスタンスで** `docker` **コマンドを** `stop` **と** `rm` **の停止アクション、および人間が読み取れるコンテナの名前を指定して実行します。
```
sudo docker stop cloud9
sudo docker rm cloud9
```
1. インスタンスから Docker イメージを削除します。これを行うには、**`docker`** アクションおよびイメージタグを使用して **`image rm`** コマンドをインスタンスで実行します。
```
sudo docker image rm cloud9-image:latest
```
1. まだ残っているすべての追加 Docker ファイルを削除します。これを行うには、**`docker`** アクションを使用して **`system prune`** コマンドをインスタンスで実行します。
```
sudo docker system prune -a
```
1. Docker をアンインストールします。これを行うには、インスタンスで** `yum` **コマンドを** `remove` **アクションを指定して実行し、アンインストールする** `docker` **パッケージを指定します。
Amazon Linux の場合:
```
sudo yum -y remove docker
```
Ubuntu Server の場合:
```
sudo apt -y remove docker
```
また、前のステップで作成した `Dockerfile` ファイルおよび `authorized_keys` ファイルを削除することもできます。例えば、インスタンスで **`rm`** コマンドを実行します。
```
sudo rm /tmp/Dockerfile
sudo rm /tmp/authorized_keys
```
### ステップ 6.4: インスタンスの終了
Amazon EC2 インスタンスを終了するには、「*Amazon EC2 ユーザーガイド*」 の 「[インスタンスの終了](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html)」を参照します。
## 関連チュートリアル
+ [AWS RoboMaker デベロッパーガイドの](https://docs.aws.amazon.com/robomaker/latest/dg/getting-started.html)*AWS RoboMaker *の開始方法」。このチュートリアルでは、 AWS Cloud9 を使用してサンプルロボットアプリケーションを変更、構築、バンドルします。