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 Cloud9 搭配各種程式設計語言 AWS 和服務的知識和信心。
**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 CloudShell，但您啟動的命令沒有字`aws`首。
建立此範例可能會導致 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 開發環境。**本範例假設您已具備 EC2 環境，且該環境已連線到執行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 執行個體。如果您有不同類型的環境或作業系統，您可能需要依照此範例的說明來設定相關工具。如需詳細資訊，請參閱[在 中建立環境 AWS Cloud9](create-environment.md)。
+ **您已開啟現有環境的 AWS Cloud9 IDE。**當您開啟環境時，請在 Web 瀏覽器中 AWS Cloud9 開啟該環境的 IDE。如需詳細資訊，請參閱[在 中開啟環境 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 環境，請在終端機中逐一執行這三個命令以安裝 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 環境，請改為在終端機中逐一執行這三個命令以安裝 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 並未安裝，請在終端機中逐一執行下列三個命令加以安裝。
```
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 是否具有進行該呼叫的適當許可。如果登入資料未涵蓋適當許可，呼叫即會失敗。
如果您使用的是 an 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 CLI 或 **`aws s3 mb`**命令搭配 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 CLI 或 **`aws s3 rb`**命令搭配 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 教學課程來設定 AWS Cloud9 開發環境，以在 CodeCommit 中與遠端程式碼儲存庫互動。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 開發環境。**本範例假設您已具備 EC2 環境，且該環境已連線到執行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 執行個體。如果您有不同類型的環境或作業系統，您可能需要依照此範例的說明來設定相關工具。如需詳細資訊，請參閱[在 中建立環境 AWS Cloud9](create-environment.md)。
+ **您已開啟現有環境的 AWS Cloud9 IDE。**當您開啟環境時，請在 Web 瀏覽器中 AWS Cloud9 開啟該環境的 IDE。如需詳細資訊，請參閱[在 中開啟環境 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 主控台。方法如下：從主控台的導覽列選擇 **Services** (服務)，然後，選擇 **IAM**。
1. 選擇 **Groups (群組)**。
1. 選擇群組的名稱。
1. 在 **Permissions** (許可) 標籤上，針對 **Managed Policies** (受管政策)，選擇 **Attach Policy** (連接政策)。
1. 在政策名稱清單中，選取下列其中一個方塊：
+ 選取 **AWSCodeCommitPowerUser**，可存取 CodeCommit 的所有功能，以及儲存庫相關資源。不過，這不允許您刪除 CodeCommit 儲存庫，或建立或刪除其他資源中的儲存庫相關資源 AWS 服務，例如 Amazon CloudWatch Events。
+ 選取 **AWSCodeCommitFullAccess**，以完全控制 中的 CodeCommit 儲存庫和相關資源 AWS 帳戶。這包括刪除儲存庫的能力。
如果您在清單中未看到上述任一政策名稱，請在 **Filter (篩選條件)** 方塊中輸入政策名稱來顯示它們。
1. 選擇 **Attach Policy (連接政策)**。
若要查看這些 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 Resource Name (ARN)。語法如下。
```
aws iam attach-group-policy --group-name MyGroup --policy-arn POLICY_ARN
```
在上述命令中，將 `MyGroup` 取代為群組的名稱。`POLICY_ARN` 將 取代為 AWS 受管政策的 ARN：
+ `arn:aws:iam::aws:policy/AWSCodeCommitPowerUser`，用於存取 CodeCommit 的所有功能，以及儲存庫相關資源。不過，它不允許您刪除 CodeCommit 儲存庫，或在 Amazon CloudWatch Events AWS 服務等其他 中建立或刪除儲存庫相關資源。
+ `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 區域 ，例如 **US East (Ohio)** (美國東部 (俄亥俄))。
1. 若顯示歡迎頁面，請選擇 **Get started** (開始使用)。否則，請選擇 **Create repository** (建立儲存庫)。
1. 在 **Create repository** (建立儲存庫) 頁面的 **Repository name** (儲存庫名稱) 中，輸入新儲存庫的名稱 (例如 `MyDemoCloud9Repo`)。如果您選擇其他名稱，請將它在此範例中皆予以取代。
1. (選用) 針對 **Description** (描述)，輸入關於儲存庫的描述。例如，您可以輸入：`This is a demonstration repository for the AWS Cloud9 sample.`
1. 選擇**建立儲存庫**。即會顯示 **Connect to your repository** (連線至儲存庫) 窗格。選擇 **Close** (關閉)，因為您將以本主題稍後的不同方式連線至儲存庫。
請直接跳到「[步驟 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。如需支援的 區域清單，請參閱 [AWS CodeCommit](https://docs.aws.amazon.com/general/latest/gr/rande.html#codecommit_region) 中的 *Amazon Web Services 一般參考*。
如果您選擇使用其他儲存庫名稱，請將它在此範例中皆予以取代。
## 步驟 3：將環境連線至遠端儲存庫
在此步驟中，您可以使用 AWS Cloud9 IDE 連線到您在上一個步驟中建立或識別的 CodeCommit 儲存庫。
**注意**
如果您偏好透過視覺化界面使用 Git，則可以複製遠端儲存庫。然後，您可以使用 IDE 中提供的 [Git 面板](source-control-gitpanel.md)功能來新增檔案。
根據您的 AWS Cloud9 開發環境類型，完成下列其中一組程序。
****
| **環境類型** | **遵循下列程序** |
| --- | --- |
| EC2 環境 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/cloud9/latest/user-guide/sample-codecommit.html) |
| SSH 環境 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/cloud9/latest/user-guide/sample-codecommit.html) |
## 步驟 4：將遠端儲存庫複製到您的環境
在此步驟中，您可以使用 AWS Cloud9 IDE 將 CodeCommit 中的遠端儲存庫複製到您的環境中。
若要複製儲存庫，請執行 **`git clone`** 命令。將 `CLONE_URL` 取代為儲存庫的複製 URL。
```
git clone CLONE_URL
```
如果是 EC2 環境，您必須提供以 `https://` 開頭的 HTTPS 複製 URL。如果是 SSH 環境，您必須提供以 `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 環境的複製儲存庫中建立三個簡單的檔案。接著，您可以將檔案新增至所複製儲存庫中的 Git 預備區域。最後，您會遞交預備檔案，並將遞交推送至 CodeCommit 中的遠端儲存庫。
如果複製的儲存庫中已經有檔案，表示您已完成，而且可以略過此範例的其餘部分。
**將檔案新增至儲存庫**
1. 建立新檔案。在選單列上，選擇 **File** (檔案)、**New File** (新增檔案)。
1. 在 檔案中輸入下列內容，然後選擇**檔案**、**儲存**以將檔案儲存為 AWS Cloud9 環境中`bird.txt`的 `MyDemoCloud9Repo`目錄。
```
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` 的檔案。將檔案儲存在相同的 `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` 目錄中。這三個檔案都會列為未追蹤檔案。
```
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 預備區域。這三個檔案現在已列為將遞交的變更。
```
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. 在 **Dashboard** (儀表板) 頁面上，選擇 **MyDemoCloud9Repo**。即會顯示三個檔案。
若要繼續實驗 CodeCommit 儲存庫，請參閱 *AWS CodeCommit 使用者指南*中的[瀏覽儲存庫內容](https://docs.aws.amazon.com/codecommit/latest/userguide/getting-started-cc.html#getting-started-cc-browse)。
如果您是初次使用 Git 且不想弄亂您的 CodeCommit 儲存庫，則可在 [Try 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
本教學課程可讓您設定 AWS Cloud9 開發環境以使用 Amazon DynamoDB。
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：新增項目到資料表](#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 開發環境。**本範例假設您已具備 EC2 環境，且該環境已連線到執行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 執行個體。如果您有不同類型的環境或作業系統，您可能需要依照此範例的說明來設定相關工具。如需詳細資訊，請參閱[在 中建立環境 AWS Cloud9](create-environment.md)。
+ **您已開啟現有環境的 AWS Cloud9 IDE。**當您開啟環境時，請在 Web 瀏覽器中 AWS Cloud9 開啟該環境的 IDE。如需詳細資訊，請參閱[在 中開啟環境 AWS Cloud9](open-environment.md)。
## 步驟 1：在您的環境中安裝和設定 AWS CLI AWS CloudShell、 或兩者
在此步驟中，您可以使用 AWS Cloud9 IDE 在環境中安裝和設定 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 CLI、aws-shell 或兩者的安裝和組態，方法是從環境中的終端機工作階段執行 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` ** 命令。
如果此命令成功，則輸出的 `TableNames` 陣列會包含您可能已有的現有 DynamoDB 資料表清單。如果您還沒有 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` 代表用來唯一識別資料表項目的屬性。此資料表的每個項目都是以數字 `ID` 屬性與 `Date` 屬性 (以 ISO-8601 格式字串呈現) 的組合予以唯一識別。
+ `--key-schema` 代表資料表的索引鍵結構描述。此資料表具有 `CityID` 和 `Date` 的複合主索引鍵。這表示每個資料表項目都必須有 `CityID` 屬性值和 `Date` 屬性值，但資料表中不能有相同 `CityID` 屬性值和 `Date` 屬性值的兩個項目。
+ `--provisioned-throughput` 代表資料表的讀寫容量。DynamoDB 允許最大達 4 KB 的項目每秒最多 5 次強式一致性讀取，或最大達 4 KB 的項目每秒最多 5 次最終一致讀取。DynamoDB 也允許最大達 1 KB 的項目每秒最多 5 次寫入。
**注意**
設定較高的佈建輸送量可能會對您的帳戶產生額外費用 AWS 。
如需上述操作和其他 DynamoDB 命令的詳細資訊，請參閱 *AWS CLI 命令參考*中的 [dynamodb](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/index.html)。
如果此命令成功，則會顯示所建立之新資料表的摘要資訊。若要確認已成功建立資料表，請執行 DynamoDB **`describe-table`** 命令，指定資料表名稱 (`--table-name`)。
```
aws dynamodb describe-table --table-name Weather
```
成功建立資料表時，`TableStatus` 值會從 `CREATING` 變更為 `ACTIVE`。除非成功建立資料表，否則請不要跳過此步驟。
## 步驟 3：新增項目到資料表
在此步驟中，您會新增項目到剛建立的資料表。
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` 代表 number 屬性值。`S` 是 string 屬性值。`M` 是 map 屬性，其為一對屬性值組。只要您使用項目，就必須指定屬性的資料類型。如需了解其他可用的屬性資料類型，請參閱 *Amazon DynamoDB 開發人員指南*中的[資料類型](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes)。
1. 執行 DynamoDB **`put-item`** 命令，並指定資料表名稱 (`--table-name`) 以及 JSON 格式的項目 (`--item`) 路徑。
```
aws dynamodb put-item \
--table-name Weather \
--item file://weather-item.json
```
如果命令成功，則執行時未發生錯誤，而且未顯示任何確認訊息。
1. 若要確認資料表的目前內容，請執行 DynamoDB **`scan`** 命令，並指定資料表名稱 (`--table-name`)。
```
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 格式的物件，其中包括包含 `PutRequest` 物件的每個 `Item` 物件。然後，您必須將這些 `PutRequest` 物件包含在名稱與資料表相同的父陣列中。
1. 執行 DynamoDB **`batch-write-item`** 命令，指定要新增的 JSON 格式項目 (`--request-items`) 的路徑。
```
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`** 命令來取得項目的相關資訊可能會很慢，尤其在資料表的大小增加或您要取得的資訊類型較複雜時更是如此。您可以建立一或多個輔助索引，以加速進行，並讓取得資訊更容易。在此步驟中，您會了解執行上述作業時，DynamoDB 支援的兩種輔助索引類型。這些稱為「本機輔助索引」**和「全域輔助索引」**。然後，您會建立全域輔助索引。
若要了解這些輔助索引類型，您需要先了解可識別資料表中唯一項目的主索引鍵。DynamoDB 支援*簡單主索引鍵*或*複合主索引鍵*。簡單主索引鍵具有單一屬性，而資料表中每個項目的屬性值都必須是唯一。此屬性也稱為*分割區索引鍵* (或*雜湊屬性*)，DynamoDB 可使用此屬性來分割項目，以便加速存取。資料表也可以有複合主索引鍵，其中包含兩個屬性。第一個屬性是分割區索引鍵，而第二個屬性是「排序索引鍵」**(也稱為「範圍屬性」**)。在具有複合主索引鍵的資料表中，任何兩個項目都可以有相同的分割區索引鍵值，但不能同時也有相同的排序索引鍵值。`Weather` 資料表具有複合主索引鍵。
本機輔助索引具有與資料表本身相同的分割區索引鍵，但此索引類型可以有不同的排序索引鍵。全域輔助索引可以有與資料表本身不同的分割區索引鍵和排序索引鍵。
例如，您可能已使用主索引鍵，以 `Weather` 存取 `CityID` 項目。若要以 `Weather` 存取 `State` 項目，您可以建立具有分割區索引鍵 `CityID` (必須與資料表本身相同) 和排序索引鍵 `State` 的本機輔助索引。若要以 `Weather` 存取 `City` 項目，您可以建立具有分割區索引鍵 `City` 和排序索引鍵 `Date` 的全域輔助索引。
您只有在建立資料表時才能建立本機輔助索引。因為 `Weather` 資料表已存在，所以您無法新增任何本機輔助索引到資料表。不過，您可以新增全域輔助索引。請現在練習新增一個全域輔助索引。
**注意**
建立輔助索引可能會使您的 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` 是要包含在索引中的屬性。分割區索引鍵一律會先列出，而任何排序索引鍵一律會後列出。
+ `--global-secondary-index-updates` 是定義全域輔助索引之檔案的路徑。
如果此命令成功，則會顯示所建立之新全域輔助索引的摘要資訊。若要確認已成功建立全域輔助索引，請執行 DynamoDB **`describe-table`** 命令，並指定資料表名稱 (`--table-name`)。
```
aws dynamodb describe-table --table-name Weather
```
成功建立全域輔助索引時，`TableStatus` 值會從 `UPDATING` 變更為 `ACTIVE`，而 `IndexStatus` 值會從 `CREATING` 變更為 `ACTIVE`。除非成功建立全域輔助索引，否則請不要跳過此步驟。這可能需要幾分鐘的時間。
## 步驟 6：取得資料表中的項目
有多種方法可以取得資料表中的項目。在此步驟中，您會使用資料表的主索引鍵、資料表的其他屬性和全域輔助索引來取得項目。
### 根據項目的主索引鍵值來取得資料表的單一項目
如果您知道項目的主索引鍵值，則可以執行 DynamoDB 命令 **`get-item`**、**`scan`** 或 **`query`** 來取得相符項目。以下是這些命令的主要差異：
+ ** `get-item` ** 會為具有指定主索引鍵的項目傳回一組屬性。
+ ** `scan` ** 會存取資料表中的每個項目或輔助索引，以傳回一或多個項目和項目屬性。
+ ** `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`。
執行 DynamoDB **`batch-get-item`** 命令，並指定檔案路徑來描述要取得的項目 (`--request-items`)。
```
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 開發環境。**本範例假設您已具備 EC2 環境，且該環境已連線到執行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 執行個體。如果您有不同類型的環境或作業系統，您可能需要依照此範例的說明來設定相關工具。如需詳細資訊，請參閱[在 中建立環境 AWS Cloud9](create-environment.md)。
+ **您已開啟現有環境的 AWS Cloud9 IDE。**當您開啟環境時，請在 Web 瀏覽器中 AWS Cloud9 開啟該環境的 IDE。如需詳細資訊，請參閱[在 中開啟環境 AWS Cloud9](open-environment.md)。
## 步驟 1：安裝必要工具
在此步驟中，您會在環境中安裝 AWS CDK 所需的所有工具，以執行以 TypeScript 程式設計語言撰寫的範例。
1. [Node Version Manager](#sample-cdk-install-nvm) 或 ** `nvm` ** (用於稍後安裝 Node.js)。
1. 範例需要的 [Node.js](#sample-cdk-install-nodejs)，其中包含 Node Package Manager 或 ** `npm` **，您用來安裝 TypeScript 和 AWS CDK 更新版本。
1. [TypeScript](#sample-cdk-install-typescript)，其為此範例所需。( AWS CDK 也支援數種其他程式設計語言。)
1. [AWS CDK](#sample-cdk-install-cdk)。
### 步驟 1.1：安裝 Node Version Manager (nvm)
1. 在 IDE AWS Cloud9 的終端機工作階段中，確保已安裝最新的安全性更新和錯誤修正。若要這麼做，請執行 **`yum update`** 命令 (適用於 Amazon Linux) 或 **`apt update`** 命令 (適用於 Ubuntu Server)。(若要啟動新終端機工作階段，請在選單列上，選擇 **Window** (視窗)、**New Terminal** (新增終端機)。
針對 Amazon Linux：
```
sudo yum -y update
```
針對 Ubuntu Server：
```
sudo apt update
```
1. 確認是否已安裝 ** `nvm` **。若要這樣做，請執行 ** `nvm` ** 命令與 ** `--version` **選項。
```
nvm --version
```
如果成功，輸出內容會包含 **`nvm`** 版本編號，而您可以直接跳到 [步驟 1.2：安裝 Node.js](#sample-cdk-install-nodejs)。
1. 下載並安裝 ** `nvm` **。若要執行此操作，請執行安裝指令碼。這個範例已安裝 v0.33.0，但您可以[在此](https://github.com/nvm-sh/nvm#installing-and-updating)確認最新版本的 **`nvm`** 。
```
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.0/install.sh | bash
```
1. 開始使用 ** `nvm` **。您可以先關閉終端機工作階段，然後再重新啟動，或是援引 `~/.bashrc` 檔案，其中包含載入 ** `nvm` ** 的命令。
```
. ~/.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. 透過使用 **`install`**動作執行 **`nvm`**命令來安裝 Node.js 16。
**注意**
您也可以執行 **`nvm install node`**來安裝 Node.js. AWS Cloud9 support 的長期支援 (LTS) 版本，以追蹤 Node.js 的 LTS 版本。
```
nvm install v16
```
1. 開始使用 Node.js 16。若要執行此操作，請執行 ** `nvm` ** 命令與 ** `alias` ** 動作、對應別名的版本編號，以及用於該別名的版本，如下所示。
```
nvm alias default 16
```
**注意**
上述命令會將 Node.js 16 設定為 Node.js 的預設版本。或者，您可以執行 ** `nvm` ** 命令與 ** `use` ** 動作，而不是 ** `alias` ** 動作 (例如，** `nvm use 16.17.0` **)。不過，** `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 已安裝。若要執行此操作，請執行命令列 TypeScript 編譯器及 ** `--version` ** 選項。
```
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. AWS CDK 透過執行 **`npm`**命令以及 `install`動作、要安裝的 AWS CDK 套件名稱，以及在環境中全域安裝套件`-g`的選項來安裝 。
```
npm install -g aws-cdk
```
1. 確認 AWS CDK 已安裝並正確參考。若要這樣做，請執行 ** `cdk` ** 命令與 ** `--version` **選項。
```
cdk --version
```
如果成功，則會顯示 AWS CDK 版本和建置編號。
## 步驟 2：新增程式碼
在此步驟中，您會建立範例 TypeScript 專案，其中包含 AWS CDK 以程式設計方式部署 AWS CloudFormation 堆疊所需的所有原始程式碼。此堆疊會在您的帳戶中建立 Amazon SNS 主題和 Amazon SQS 佇列， AWS 然後訂閱該主題的佇列。
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。
+ 包含 `hello-cdk-stack.ts` 檔案的 `lib` 子目錄。此檔案包含 AWS CDK 堆疊的程式碼。此程式碼描述於此程序的後續步驟。
+ 包含 `hello-cdk.ts` 檔案的 `bin` 子目錄。此檔案包含您 AWS CDK 應用程式的進入點。
+ `node_modules` 子目錄，其中包含支援的程式碼套件，其可供應用程式和堆疊視需來使用。
+ 隱藏的 `.npmignore` 檔案，其中列出當建置程式碼時 ** `npm` ** 不需要的子目錄和檔案類型。
+ `cdk.json` 檔案，其中包含可讓 ** `cdk` ** 命令更輕鬆地執行的資訊。
+ `package-lock.json` 檔案，其中包含 ** `npm` ** 可用於降低可能的建置和執行錯誤的相關資訊。
+ `package.json` 檔案，其中包含可讓 ** `npm` ** 命令更輕鬆地執行，且減少建置和執行錯誤的相關資訊。
+ `README.md` 檔案，列出您可以使用 **`npm`**和 執行的實用命令 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`、`Queue`、 `StackProps`和 `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`的檔案。若要執行此操作，請從專案的根目錄以 ** `run` ** 動作執行 ** `npm` ** 命令, 且需將 `package.json` 檔案中的 ** `build` ** 命令值指定如下。
```
npm run build
```
上述命令會執行 TypeScript 編譯器，這會新增對 `bin/hello-cdk.d.ts` 和 `lib/hello-cdk-stack.d.ts` 檔案的支援。這個編譯器也會將 `hello-cdk.ts` 和 `hello-cdk-stack.ts` 檔案轉換為 `hello-cdk.js` 和 `hello-cdk-stack.js` 檔案。
## 步驟 3：執行程式碼
在此步驟中，您會指示 根據 `bin/hello-cdk.js` 檔案中的程式碼 AWS CDK 建立 CloudFormation 堆疊範本。然後 AWS CDK ，指示 部署堆疊，這會建立 Amazon SNS 主題和 Amazon SQS 佇列，然後訂閱該主題的佇列。然後，確認已成功部署主題和佇列，做法是從主題傳送訊息到佇列。
1. 讓 AWS CDK 建立 CloudFormation 堆疊範本。若要執行此操作，請在 IDE 仍開啟終端機工作階段的情況下，從專案的根目錄，以 **`synth`** 動作和堆疊的名稱執行 **`cdk`** 命令。
```
cdk synth HelloCdkStack
```
如果成功，輸出會顯示 CloudFormation 堆疊範本的 `Resources` 區段。
1. 第一次將 AWS CDK 應用程式部署到特定 AWS 帳戶和 AWS 區域組合的環境時，您必須安裝*引導堆疊*。此堆疊包含 完成其各種操作 AWS CDK 所需的各種資源。例如，此堆疊包含 Amazon S3 儲存貯體，用於在其部署程序期間 AWS CDK 存放範本和資產。若要安裝引導堆疊，請執行 ** `cdk` ** 命令，搭配 ** `bootstrap` **動作。
```
cdk bootstrap
```
**注意**
如果您在`cdk bootstrap`未指定任何選項的情況下執行 ，則會使用預設 AWS 帳戶和 AWS 區域。您也可以指定設定檔和帳戶/區域組合來引導特定環境。例如：
```
cdk bootstrap --profile test 123456789012/us-east-1
```
1. 讓 AWS CDK 執行 CloudFormation 堆疊範本以部署堆疊。若要執行此操作，請自專案的根目錄執行 ** `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 Resource Name (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
```
在上述命令中，`arn:aws:sns:us-east-2:123456789012:HelloCdkStack-HelloCdkTopic1A234567-8BCD9EFGHIJ0K`將 取代為 CloudFormation 指派給主題的 ARN。若要取得 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
```
在上述命令中，將 取代`https://queue.amazonaws.com/123456789012/HelloCdkStack-HelloCdkQueue1A234567-8BCD9EFGHIJ0K`為 CloudFormation 指派給佇列的 ARN。若要取得 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、ApacheHTTP 伺服器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 開發環境。**本範例假設您已具備 EC2 環境，且該環境已連線到執行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 執行個體。如果您有不同類型的環境或作業系統，您可能需要依照此範例的說明來設定相關工具。如需詳細資訊，請參閱[在 中建立環境 AWS Cloud9](create-environment.md)。
+ **您已開啟現有環境的 AWS Cloud9 IDE。**當您開啟環境時，請在 Web 瀏覽器中 AWS Cloud9 開啟該環境的 IDE。如需詳細資訊，請參閱[在 中開啟環境 AWS Cloud9](open-environment.md)。
## 步驟 1：安裝工具
在此步驟中，您將安裝下列工具：
+ Apache HTTP Server，這是 Web 伺服器主機。
+ PHP，這是一種指令碼語言，尤其適用於 Web 開發並可內嵌到 HTML。
+ MySQL，這是一種關聯式資料庫管理系統。
然後，先啟動 Apache HTTP Server 再啟動 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 Server：
```
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 Server：
```
sudo apt install -y apache2
```
1. 執行 **`php -v`** 命令，確認是否已安裝 PHP。
如果成功，輸出會包含 PHP 版本號碼。
如果您看到錯誤，則執行 **`install`** 命令來安裝 PHP。
針對 Amazon Linux：
```
sudo yum install -y php56
```
針對 Ubuntu Server：
```
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 Server：
```
sudo apt install -y mysql-server
```
1. 在您安裝 Apache HTTP Server、PHP 和 MySQL 之後，請啟動 Apache HTTP Server，然後執行以下命令來確認它已啟動。
若為 Amazon Linux (您可能需要執行此命令兩次)：
```
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. 在 AWS Cloud9 IDE 的終端機工作階段中執行以下命令，針對 MySQL 安裝實作 MySQL 安全最佳實務。
```
sudo mysql_secure_installation
```
1. 出現提示時，回答下列指定的問題。
針對 Amazon Linux：
1. **輸入根目錄目前使用的密碼 (若無密碼，請按 Enter)** – 按 `Enter` (若沒有密碼)。
1. **設定根密碼** - 輸入 `Y`，然後按 `Enter`。
1. **新密碼** - 輸入密碼，然後按 `Enter`。
1. **重新輸入新密碼** - 重新輸入密碼，然後按 `Enter`。(請務必將密碼存放在安全位置，以供日後使用。)
1. **移除匿名使用者** - 輸入 `Y`，然後按 `Enter`。
1. **不允許從遠端進行根登入** - 輸入 `Y`，然後按 `Enter`。
1. **移除測試資料庫和其存取權** - 輸入 `Y`，然後按 `Enter`。
1. **立即重新載入權限表格** - 輸入 `Y`，然後按 `Enter`。
針對 Ubuntu Server：
1. **是否要設定 VALIDATE PASSWORD 外掛程式** - 輸入 `y`，然後按 `Enter`。
1. **有三種層級的密碼驗證政策** - 輸入 `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 命令列用戶端。出現提示時，輸入您先前設定的根使用者密碼，然後按 `Enter`。當您使用 MySQL 命令列用戶端時，提示會變更為 `mysql>`。
```
sudo mysql -uroot -p
```
1. 若要結束 MySQL 命令列用戶端，請執行以下命令。提示會變回 `$`。
```
exit;
```
## 步驟 3：設定網站
在此步驟中，您將使用建議的擁有者和存取許可來設定 Apache HTTP Server 的預設網站根目錄。然後，在預設網站根目錄內建立 PHP 型網頁。
接著，啟用傳入的 Web 流量以檢視該網頁，方法是在 Amazon EC2 中設定安全群組，並在與此 EC2 環境相關聯的 Amazon Virtual Private Cloud (Amazon VPC) 中設定網路存取控制清單 (網路 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 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 Server：
```
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. 執行以下命令，在 Apache HTTP Server 的預設網站根資料夾 (即 `/var/www/html`) 中建立名稱為 `index.php` 的 PHP 型網頁。
針對 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 Server：
```
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. 啟用透過連接埠 80 傳入的 Web 流量以檢視新網頁，方法是在 Amazon VPC 中設定網路 ACL，以及在與此 EC2 環境相關聯的 Amazon EC2 設定安全群組 。若要這樣做，請依照下列順序執行以下八個命令，一次一個。若要了解每個命令的作用，請閱讀每個命令的 `#` 字元後面的資訊。
**重要**
執行以下命令後，**所有** EC2 環境以及與此環境的安全群組和網路 ACL 相關聯的 Amazon EC2 執行個體都能接受透過連接埠 80 傳入的 Web 流量。這可能意外導致 EC2 環境以及此執行個體以外的 Amazon EC2 執行個體能夠接受透過連接埠 80 傳入的 Web 流量。
**注意**
以下第二個到第四個命令可讓安全群組允許透過連接埠 80 傳入的 web 流量。如果您有一個預設安全群組，僅允許透過連接埠 22 傳入的 SSH 流量，則必須先執行第一個命令，接著執行第二個到第四個命令。不過，如果您有一個自訂安全群組，已允許透過連接埠 80 傳入的 Web 流量，則可以略過執行那些命令。
以下第五個到第八個命令可讓網路 ACL 允許透過連接埠 80 傳入的 web 流量。如果您有一個預設網路 ACL，已允許透過所有連接埠傳入的流量，則可以安全地略過執行那些命令。不過，假設您有自訂網路 ACL，不允許透過連接埠 80 傳入的 Web 流量。然後，執行第一個命令，接著執行第五到第八個命令。
```
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. 取得 Web 伺服器根目錄內 `index.php` 檔案的 URL。若要執行此作業，請執行下列命令，並使用新的 Web 瀏覽器標籤或不同於 IDE AWS Cloud9 的不同 Web 瀏覽器，前往顯示的 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 傳入的 Web 流量。然後，依照下列順序逐一執行以下八個命令，以刪除您先前在安全群組和網路 ACL 中設定，並與環境相關聯的相應傳入流量規則。若要了解每個命令的作用，請閱讀每個命令的 `#` 字元後面的資訊。
**重要**
執行以下命令後，**所有** EC2 環境以及與此環境的安全群組和網路 ACL 相關聯的 Amazon EC2 執行個體都會拒絕透過連接埠 80 傳入的 Web 流量。這可能意外導致 EC2 環境以及此執行個體以外的 Amazon EC2 執行個體拒絕透過連接埠 80 傳入的 Web 流量。
**注意**
以下第五個到第八個命令會移除現有規則，以封鎖網路 ACL 不允許透過連接埠 80 傳入的 web 流量。如果您有一個預設網路 ACL，已允許透過所有連接埠傳入的流量，則可以略過執行那些命令。不過，假設您有一個自訂網路 ACL，其現有規則允許透過連接埠 80 傳入的 Web 流量，而且您想要刪除那些規則。然後，您需要執行第一個命令，接著執行第五到第八個命令。
```
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)，廣泛用於傳遞 Web 內容。
**注意**
遵循本教學課程並建立此範例可能會導致 AWS 您的帳戶產生費用。包括 Amazon Elastic Compute Cloud (Amazon EC2) 等服務的可能費用。如需詳細資訊，請參閱 [Amazon EC2 定價](https://aws.amazon.com/ec2/pricing/)。
## 先決條件
在您使用此範例前，請務必確認您的設定符合下列要求：
+ **您必須擁有現有的 AWS Cloud9 EC2 開發環境。**本範例假設您已具備 EC2 環境，且該環境已連線到執行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 執行個體。如果您有不同類型的環境或作業系統，您可能需要依照此範例的說明來設定相關工具。如需詳細資訊，請參閱[在 中建立環境 AWS Cloud9](create-environment.md)。
+ **您已開啟現有環境的 AWS Cloud9 IDE。**當您開啟環境時，請在 Web 瀏覽器中 AWS Cloud9 開啟該環境的 IDE。如需詳細資訊，請參閱[在 中開啟環境 AWS Cloud9](open-environment.md)。
+ **您的最新 EC2 執行個體中包含所有最新的軟體套件**。在 AWS Cloud9 IDE 終端機視窗中，您可以使用 `yum update` `-y`選項執行 來安裝更新，而無需要求確認。如果您要先檢查更新再安裝，則可以略過此選項。
```
sudo yum update -y
```
## 安裝概觀
在您環境的 EC2 執行個體上安裝 WordPress 必須按照以下步驟操作：
1. 安裝和設定 MariaDB 伺服器，這是一種開源的關聯式資料庫，用於存放 WordPress 安裝資訊
1. 安裝和設定 WordPress，包括編輯 `wordpress.conf` 組態檔案
1. 設定代管 WordPress 網站的 Apache 伺服器
1. 預覽由 Apache 伺服器代管的 WordPress Web 內容
## 步驟 1：安裝與設定 MariaDB 伺服器
1. 在 AWS Cloud9 IDE 中，選擇**視窗**、**新終端機**，然後輸入下列命令來安裝和啟動 MariaDB Server 安裝：
```
sudo yum install -y mariadb-server
sudo systemctl start mariadb
```
1. 然後，執行 `mysql_secure_installation` 指令碼來加強 MariaDB 伺服器安裝的安全性。
向指令碼提供回應時，請對第一個問題按下 **Enter**，以便讓根密碼保持空白。對 `Set root password?` 按下 **n**，然後對其餘每個安全選項都按下 **y**。
```
mysql_secure_installation
```
1. 接下來，使用 MariaDB 用戶端建立一個資料庫資料表來存放 WordPress 資訊。
(系統要求您輸入密碼時按下 **Enter**)。
```
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 Web 內容
1. 使用 AWS Cloud9 IDE，`index.html`在下列目錄中建立名為 的新檔案：`environment/wordpress`。
1. 將 HTML 格式的文字新增至 `index.html`。例如：
```
Hello World!
```
1. 在**環境**視窗中，選擇`index.html`檔案 ，然後選擇**預覽**、**預覽執行中的應用程式**。
應用程式預覽標籤中會出現 web 頁面，顯示 *Hello World！* 訊息。若要在偏好的瀏覽器中檢視 Web 內容，請選擇 **Pop Out Into a New Window** (在新視窗中彈出)。
如果您刪除 `index.html` 檔案並重新整理應用程式預覽標籤，則 WordPress 組態頁面就會顯示。
## 管理混合內容錯誤
如果 Web 瀏覽器同時載入 HTTPS 和 HTTP 指令碼或內容，就會顯示 WordPress 網站的混合內容錯誤。錯誤訊息的用詞視您使用的 Web 瀏覽器而定，但系統會通知您與網站的連線不安全，或安全性不完整。且您的 Web 瀏覽器會封鎖混合內容的存取權。
**重要**
根據預設，您在 AWS Cloud9 IDE 應用程式預覽標籤中存取的所有 web 頁面會自動使用 HTTPS 通訊協定。如果頁面的 URI 具有不安全的 `http` 通訊協定，就會自動由 `https` 替代。而且您無法藉由手動將 `https` 改回 `http` 來存取不安全的內容。
如需了解如何為網站實作 HTTPS，請參閱 [WordPress 文件](https://wordpress.org/support/article/https-for-wordpress/)。
# 的 Java 教學課程 AWS Cloud9
**重要**
如果您使用的 AWS Cloud9 開發環境由具有 2 GiB 或更多記憶體的 EC2 執行個體支援，我們建議您啟用增強型 Java 支援。這可以提供各種生產力功能的存取權，例如程式碼完成、錯誤檢查、內容特定動作以及除錯選項 (如中斷點和逐步執行)。
如需詳細資訊，請參閱[增強對 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：設定 以使用 適用於 Java 的 AWS SDK](#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 開發環境。**本範例假設您已具備 EC2 環境，且該環境已連線到執行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 執行個體。如果您有不同類型的環境或作業系統，您可能需要依照此範例的說明來設定相關工具。如需詳細資訊，請參閱[在 中建立環境 AWS Cloud9](create-environment.md)。
+ **您已開啟現有環境的 AWS Cloud9 IDE。**當您開啟環境時，請在 Web 瀏覽器中 AWS Cloud9 開啟該環境的 IDE。如需詳細資訊，請參閱[在 中開啟環境 AWS Cloud9](open-environment.md)。
## 步驟 1：安裝必要工具
在此步驟中，您會在開發環境中安裝一組 Java AWS Cloud9 開發工具。如果您已在環境中安裝一組 Java 開發工具，例如 Oracle JDK 或 OpenJDK，您可以直接跳到 [步驟 2：新增程式碼](#sample-java-code)。此範例以 OpenJDK 8 開發，完成下列程序後您就可將此範例安裝在您的環境中。
1. 確認是否已安裝 OpenJDK 8。若要這樣做，請在 IDE AWS Cloud9 的終端機工作階段中，使用 **`-version`**選項執行 Java Runner 的命令列版本。(若要啟動新終端機工作階段，請在選單列上，選擇 **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. 確定已安裝最新的安全性更新和錯誤修正。若要這樣做，請以 **`update`** 命令執行 yum 工具 (適用於 Amazon Linux) 或 apt 工具 (適用於 Ubuntu Server)。
針對 Amazon Linux：
```
sudo yum -y update
```
針對 Ubuntu Server：
```
sudo apt update
```
1. 安裝 OpenJDK 8。若要這樣做，請以 **`install`** 命令執行 yum 工具 (適用於 Amazon Linux) 或 apt 工具 (適用於 Ubuntu Server)，並指定 OpenJDK 8 套件。
針對 Amazon Linux：
```
sudo yum -y install java-1.8.0-openjdk-devel
```
針對 Ubuntu Server：
```
sudo apt install -y openjdk-8-jdk
```
如需詳細資訊，請參閱 OpenJDK 網站上的[如何下載和安裝預先建置的 OpenJDK 套件](https://openjdk.org/install/)。
1. 將預設的 Java 開發工具組切換或升級為 OpenJDK 8。若要這樣做，請執行 ** `update-alternatives` ** 命令與 ** `--config` **選項。執行此命令兩次，以切換或升級 Java runner 和編譯器的命令列版本。
```
sudo update-alternatives --config java
sudo update-alternatives --config javac
```
在每個提示中，輸入 OpenJDK 8 的選擇號碼 (包含 `java-1.8`)。
1. 確認 Java runner 和編譯器命令列版本使用的是 OpenJDK 8。若要執行此操作，執行 Java runner 和編譯器的命令列版本並使用 `-version` 選項。
```
java -version
javac -version
```
如果 OpenJDK 8 已安裝並正確設定，Java runner 版本輸出將包含以 `openjdk version 1.8` 起始的值，而且 Java 編譯器版本輸出以 `javac 1.8` 起始的值。
## 步驟 2：新增程式碼
在 AWS Cloud9 IDE 中，使用下列程式碼建立檔案，並使用名稱 儲存檔案`hello.java`。(若要建立檔案，請在選單列上選擇 **File** (檔案)、**New File** (新增檔案)。若要儲存檔案，請選擇 **File** (檔案)、**Save** (儲存)。)
```
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` 檔案相同的目錄執行 Java 編譯器，指定 `hello.java` 檔案。
```
javac hello.java
```
1. 使用 Java runner 的命令列版本執行 `hello.class` 檔案。若要這樣做，從與 `hello.class` 檔案相同的目錄執行 Java runner，並指定在 `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：設定 以使用 適用於 Java 的 AWS SDK
您可以增強此範例，以使用 適用於 Java 的 AWS SDK 建立 Amazon S3 儲存貯體、列出可用的儲存貯體，然後刪除您剛建立的儲存貯體。
在此步驟中，您會在環境中安裝 [Apache Maven](https://maven.apache.org/) 或 [Gradle](https://gradle.org/)。Maven 和 Gradle 是通用建置自動化系統，可搭配使用 Java 專案。在安裝 Maven 或 Gradle 之後，您可以使用它來產生新的 Java 專案。在這個新專案中，您會新增 適用於 Java 的 AWS SDK的參考。這 適用於 Java 的 AWS SDK 可讓您透過 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 Server，改為執行下列命令。
```
sudo apt install -y maven
```
1. 執行 Maven 並使用** `-version` **選項以確認安裝。
```
mvn -version
```
1. 使用 Maven 產生新的 Java 專案。若要這樣做，請使用終端機從您希望 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 Project 網站上的 [Maven 快速入門 Archetype](https://maven.apache.org/archetypes/maven-archetype-quickstart/) 和 [ 認識標準目錄配置](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` 設定項目，可設定 `my-app-1.0-SNAPSHOT-jar-with-dependencies.jar` 的輸出 JAR 檔案名稱。
+ `plugin` 區段宣告將建置單一 JAR，其中包含所有相依性。
+ 設定 `groupId``com.amazon.aws`和`artifactId`設定 的 `dependency`區段`aws-java-sdk`包含程式 適用於 Java 的 AWS SDK 庫檔案。要使用的 適用於 Java 的 AWS SDK 版本是以 `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 安裝最新版本的 Gradle。
```
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install gradle
```
如需有關前述命令的詳細資訊，請參閱 SDKMAN\$1 網站的[安裝](https://sdkman.io/install)，以及 Gradle 網站的[使用套件軟體管理工具進行安裝](https://gradle.org/install/#with-a-package-manager)。
1. 執行 Gradle 並使用** `-version` **選項以確認安裝。
```
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` 外掛程式用於匯入 適用於 Java 的 AWS SDK Maven 物料清單 (BOM)，以管理專案的 適用於 Java 的 AWS SDK 相依性。 `classpath`宣告要使用的版本。若要使用不同的版本，請取代此版本編號。
+ `com.amazonaws:aws-java-sdk-s3` 包含 適用於 Java 的 AWS SDK 程式庫檔案的 Amazon S3 部分。`mavenBom` 會宣告要使用的版本。如果您要使用不同的版本，請取代此版本編號。
## 步驟 5：在您的環境中設定 AWS 登入資料管理
每次使用 適用於 Java 的 AWS SDK 來呼叫 AWS 服務時，您必須隨呼叫提供一組 AWS 登入資料。這些登入資料會判斷 是否 適用於 Java 的 AWS SDK 具有進行該呼叫的適當許可。如果登入資料未涵蓋適當許可，呼叫即會失敗。
在此步驟中，您會在環境中存放您的憑證。若要這麼做，請遵循 [AWS 服務 從 中的環境呼叫 AWS Cloud9](credentials.md) 中的指示，然後返回本主題。
如需其他資訊，請參閱 *適用於 Java 的 AWS SDK 開發人員指南*中的[設定開發用的 AWS 憑證和區域](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html#setup-credentials)。
## 步驟 6：新增 AWS SDK 程式碼
在此步驟中，您會新增程式碼以與 Amazon S3 互動，藉此建立儲存貯體、列出可用的儲存貯體，然後刪除您剛建立的儲存貯體。
從 **Environment** (環境) 視窗，開啟 `my-app/src/main/java/com/mycompany/app/App.java` 檔案 (適用於 Maven) 或開啟 `my-app/src/main/java/App.java` 檔案 (適用於 Gradle)。在編輯器中，使用以下程式碼取代該檔案的目前內容，然後儲存 `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 runner 執行 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 程式碼。程式碼也會使用 [適用於 C\$1\$1 的 AWS SDK](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 和所需的開發套件](#sample-cplusplus-install)
+ [步驟 2：安裝 CMake](#install-cmake)
+ [步驟 3：取得並建置適用於 C\$1\$1 的 SDK](#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 開發環境。**本範例假設您已具備 EC2 環境，且該環境已連線到執行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 執行個體。如果您有不同類型的環境或作業系統，您可能需要依照此範例的說明來設定相關工具。如需詳細資訊，請參閱[在 中建立環境 AWS Cloud9](create-environment.md)。
+ **您已開啟現有環境的 AWS Cloud9 IDE。**當您開啟環境時，請在 Web 瀏覽器中 AWS Cloud9 開啟該環境的 IDE。如需詳細資訊，請參閱[在 中開啟環境 AWS Cloud9](open-environment.md)。
## 步驟 1：安裝 g \$1\$1 和所需的開發套件
要建置和執行 C\$1\$1 應用程式，你需要 `g++` 這類應用程式，它是由 [GNU 編譯器集合 (GCC)](https://gcc.gnu.org/) 所提供的 C\$1\$1 編譯器。
您還需要新增 `libcurl`、`libopenssl`、`libuuid`、`zlib` 的標題檔案 (`-dev` 套件)，以及支援 Amazon Polly 的 `libpulse` (選用)。
視您使用的是 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. 接下來，執行 Bootstrap 指令碼並執行下列命令來安裝 `cmake`：
```
./bootstrap
make
sudo make install
```
1. 執行下列命令來確認您已安裝此工具：
```
cmake --version
```
## 步驟 3：取得並建置適用於 C\$1\$1 的 SDK
若要設定適用於 C\$1\$1 的 AWS SDK，您可以直接從來源自行建置 SDK，或使用套件管理員下載程式庫。您可以在《 *適用於 C\$1\$1 的 AWS SDK 開發人員指南*》中的[使用適用於 C\$1\$1 的 AWS SDK 入門](https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/getting-started.html)中找到可用選項的詳細資訊。
此範例將示範如何使用 `git` 來複製 SDK 來源碼，以及使用 `cmake` 來建置 C\$1\$1 的 SDK。
1. 在終端機中執行下列命令，即可為 AWS Cloud9 環境複製遠端儲存庫並以遞迴方式取得所有 Git 子模組來：
```
git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp
```
1. 導覽至新`aws-sdk-cpp`目錄，建立子目錄以建置適用於 C\$1\$1 的 AWS SDK，然後導覽至該目錄：
```
cd aws-sdk-cpp
mkdir sdk_build
cd sdk_build
```
1.
**注意**
為了節省時間，此步驟僅會建置 適用於 C\$1\$1 的 AWS SDK的 Amazon S3 部分。如果您想要建置完整的 SDK，請刪減 `cmake` 命令中的 `-DBUILD_ONLY=s3`。
為 C\$1\$1 建置完整 SDK 可能需要一個多小時才會完成，具體時間視您的 Amazon EC2 執行個體或自有伺服器中的可用運算資源而定。
執行下列命令，藉此使用 `cmake` 在 `sdk_build` 目錄中建置 C\$1\$1 SDK 的 Amazon S3 部分：
```
cmake .. -DBUILD_ONLY=s3
```
1. 接著請執行 `make install` 命令，以便使建置的 SDK 可供存取：
```
sudo make install
cd ..
```
## 步驟 4：建立 C \$1\$1 和 CMakeLists 檔案
在此步驟中，您會建立 `C++` 檔案，藉此允許專案的使用者與 Amazon S3 儲存貯體互動。
您也可以建立 `CMakeLists.txt` 檔案，來提供 `cmake` 建置 C\$1\$1 程式庫時使用的指示。
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. 再另外建立含有以下內容的檔案，然後儲存檔案到您環境的根目錄 (`/`) 並命名為 `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：安裝和設定 適用於 Python (Boto3) 的 AWS SDK](#sample-python-sdk)
+ [步驟 5：新增 AWS SDK 程式碼](#sample-python-sdk-code)
+ [步驟 6：執行 AWS SDK 程式碼](#sample-python-sdk-run)
+ [步驟 7：清除](#sample-python-clean-up)
## 先決條件
在您使用此教學前，請務必符合下列要求。
+ **您有 an AWS Cloud9 EC2 開發環境**
此教學假設您已具備 EC2 環境，且該環境已連線到執行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 執行個體。如需詳細資訊，請參閱 [建立 EC2 環境](create-environment-main.md)。
如果您有不同類型的環境或作業系統，您可能需要調整此教學的操作指示。
+ **您已開啟該環境的 AWS Cloud9 IDE**
當您開啟環境時，請在 Web 瀏覽器中 AWS Cloud9 開啟該環境的 IDE。如需詳細資訊，請參閱 [在 中開啟環境 AWS Cloud9](open-environment.md)。
## 步驟 1：安裝 Python
1. 在 IDE AWS Cloud9 的終端機工作階段中，執行 **`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`。(若要建立檔案，請在選單列上選擇 **File** (檔案)、**New File** (新增檔案)。若要儲存檔案，請選擇 **File** (檔案)、**Save** (儲存)。)
```
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 的選單列中，選擇**執行**、**執行組態**、**新執行組態**。
1. 在 **[New] - Stopped** ([新增] - 已停止) 索引標籤中，為 **Command** (命令) 輸入 `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：安裝和設定 適用於 Python (Boto3) 的 AWS SDK
適用於 Python (Boto3) 的 AWS SDK 可讓您使用 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/)。
### 安裝 適用於 Python (Boto3) 的 AWS SDK
安裝 之後`pip`， 適用於 Python (Boto3) 的 AWS SDK 請執行 **`pip install`**命令來安裝 。
```
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)快速入門 適用於 Python (Boto3) 的 AWS SDK的「安裝」一節。
### 在環境中設定憑證
每次使用 適用於 Python (Boto3) 的 AWS SDK 來呼叫 AWS 服務時，您必須隨呼叫提供一組登入資料。這些登入資料會判斷 SDK 是否具備適當許可，能夠發出該次呼叫。如果登入資料未涵蓋必要的許可，呼叫會失敗。
若要將憑證存放在環境中，請遵循 [AWS 服務 從 中的環境呼叫 AWS Cloud9](credentials.md) 中的指示，然後返回本主題。
如需詳細資訊，請參閱《[》章節](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html)登入資料 適用於 Python (Boto3) 的 AWS SDK。
## 步驟 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 主控台應用程式專案 適用於 .NET 的 AWS SDK](#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 開發環境。**本範例假設您已具備 EC2 環境，且該環境已連線到執行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 執行個體。如果您有不同類型的環境或作業系統，您可能需要依照此範例的說明來設定相關工具。如需詳細資訊，請參閱[在 中建立環境 AWS Cloud9](create-environment.md)。
+ **您已開啟現有環境的 AWS Cloud9 IDE。**當您開啟環境時，請在 Web 瀏覽器中 AWS Cloud9 開啟該環境的 IDE。如需詳細資訊，請參閱[在 中開啟環境 AWS Cloud9](open-environment.md)。
## 步驟 1：安裝必要工具
在此步驟中，您會將 .NET 開發套件安裝到您的環境，這是執行此範例的必要項目。
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 開發套件。
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 開發套件。
```
./dotnet-install.sh -c Current
```
1. 將 .NET 開發套件新增至您的 `PATH`。若要這樣做，請在環境的 shell 描述檔 (例如，`.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` 兩次，接著在檔案結尾單獨輸入以下這一行。
```
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` 目錄。您應該會注意到以下兩個重要檔案：
+ `hello/hello.csproj` 檔案包含有關主控台應用程式專案的資訊。
+ `hello/Program.cs` 檔案包含要執行的應用程式的程式碼。
## 步驟 4：新增程式碼
在此步驟中，您將新增一些程式碼到應用程式。
從 **IDE 中的環境**視窗中，開啟 `hello/Program.cs` 檔案。 AWS Cloud9
在編輯器中，使用以下程式碼取代該檔案的目前內容，然後儲存 `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. 在 IDE 中，建立適用於 .NET 的建置器，如下所示。
1. 從功能表列選擇 **Run, Build System, New Build System (執行、建置系統、新建置系統)**。
1. 在 **My Builder.build (我的 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` 子目錄中。請注意以下三個重要檔案。
+ `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 (我的 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. 執行應用程式並搭配要新增的兩個整數 (例如，`5` 和 `9`)，如下所示。
1. 使用顯示在編輯器中的 `Program.cs` 檔案內容，選擇 **Run, Run Configurations, New Run Configuration (執行、執行組態、新增執行組態)**。
1. 在 **【新增】 - 閒置**索引標籤中，選擇**執行器：自動**，然後選擇 **.NET**。
1. 在 **Command (命令)** 方塊中，輸入 `hello 5 9`。
1. 選擇**執行**。
根據預設，此執行器會指示 .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 主控台應用程式專案 適用於 .NET 的 AWS SDK
您可以增強此範例，以使用 適用於 .NET 的 AWS SDK 建立 Amazon S3 儲存貯體、列出可用的儲存貯體，然後刪除您剛建立的儲存貯體。
在這個新專案中，您會新增 適用於 .NET 的 AWS SDK的參考。 適用於 .NET 的 AWS SDK 提供便捷的方式，讓您從 .NET 程式碼與 Amazon S3 等 AWS 服務互動。然後，您可以在環境中設定 AWS 登入資料管理。 適用於 .NET 的 AWS SDK 需要這些登入資料才能與 AWS 服務互動。
### 建立專案
1. 建立 .NET 主控台應用程式專案。若要這樣做，請使用 **`new`**命令執行 .NET CLI，指定主控台應用程式專案範本類型和要使用的程式設計語言。
`-n` 選項表示專案經輸出到新的目錄 `s3` 中。接著導覽至該目錄。
```
dotnet new console -lang C# -n s3
cd s3
```
1. 在 適用於 .NET 的 AWS SDK中新增 Amazon S3 套件的專案參考。若要執行此操作，請使用 **`add package`**命令執行 .NET CLI，並在 NuGet 中指定 Amazon S3 套件的名稱。(NuGet 定義如何建立、託管和消耗 .NET 套件，並提供這些角色的工具。)
```
dotnet add package AWSSDK.S3
```
當您新增 Amazon S3 套件的專案參考時，NuGet 也會在其餘 適用於 .NET 的 AWS SDK中新增專案參考。
**注意**
如需 NuGet 中其他 AWS 相關套件的名稱和版本，請參閱 [NuGet 網站上的標記 aws-sdk 的 NuGet 套件](https://www.nuget.org/packages?q=Tags%3A%22aws-sdk%22)。 NuGet
### 設定 AWS 登入資料管理
每次使用 適用於 .NET 的 AWS SDK 來呼叫 AWS 服務時，您必須隨呼叫提供一組 AWS 登入資料。這些登入資料會判斷 是否 適用於 .NET 的 AWS SDK 具有進行該呼叫的適當許可。如果登入資料未涵蓋適當許可，呼叫即會失敗。
若要將憑證存放在環境中，請遵循 [AWS 服務 從 中的環境呼叫 AWS Cloud9](credentials.md) 中的指示，然後返回本主題。
如需詳細資訊，請參閱《 *適用於 .NET 的 AWS SDK 開發人員指南*》中的[設定 AWS 登入](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html)資料。
## 步驟 7：新增 AWS SDK 程式碼
在此步驟中，您會新增程式碼與 Amazon S3 互動，藉此建立儲存貯體、刪除您剛建立的儲存貯體，然後列出可用的儲存貯體。
從 **IDE 中的環境**視窗中，開啟 `s3/Program.cs` 檔案。 AWS Cloud9 在編輯器中，使用以下程式碼取代該檔案的目前內容，然後儲存 `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. 建置專案。若要執行此操作，請使用顯示在編輯器中的 `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. 選擇**執行**。
根據預設，此執行器會指示 .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 中安裝和設定適用於 JavaScript 的 AWS SDK](#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 開發環境。**本範例假設您已具備 EC2 環境，且該環境已連線到執行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 執行個體。如果您有不同類型的環境或作業系統，您可能需要依照此範例的說明來設定相關工具。如需詳細資訊，請參閱[在 中建立環境 AWS Cloud9](create-environment.md)。
+ **您已開啟現有環境的 AWS Cloud9 IDE。**當您開啟環境時，請在 Web 瀏覽器中 AWS Cloud9 開啟該環境的 IDE。如需詳細資訊，請參閱[在 中開啟環境 AWS Cloud9](open-environment.md)。
## 步驟 1：安裝必要工具
在此步驟中，您將安裝 Node.js，其為執行本範例的必要元件。
1. 在 IDE AWS Cloud9 的終端機工作階段中，執行 **`node --version`**命令以確認是否已安裝 Node.js。(若要啟動新終端機工作階段，請在選單列上，選擇 **Window** (視窗)、**New Terminal** (新增終端機)。如果成功，輸出會包含 Node.js 版本編號。若 Node.js 已安裝，請跳至[步驟 2：新增程式碼](#sample-nodejs-code)。
1. 執行 **`yum update`** (適用於 Amazon Linux) 或 **`apt update`** (適用於 Ubuntu Server) 命令，協助確保已安裝最新安全性更新和錯誤修正。
針對 Amazon Linux：
```
sudo yum -y update
```
針對 Ubuntu Server：
```
sudo apt update
```
1. 若要安裝 Node.js，請執行此命令來下載 Node Version Manager (nvm)。(nvm 是一種簡單的 Bash shell 指令碼，適用於安裝和管理 Node.js 版本。如需詳細資訊，請參閱 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，請先關閉終端機工作階段並再次啟動，或是援引 `~/.bashrc` 檔案，其中包含的命令將會載入 nvm。
```
. ~/.bashrc
```
1. 執行此命令以在 Amazon Linux 2、Amazon Linux 1 和 Ubuntu 18.04 上安裝 Node.js 16。Amazon Linux 1 和 Ubuntu 18.04 執行個體僅支援 Node.js 至 v16。
```
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。如果您想要 AWS Cloud9 手動在 Amazon Linux 2 上安裝 Node.js 18，請在 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`。(若要建立檔案，請在選單列上選擇 **File** (檔案)、**New File** (新增檔案)。若要儲存檔案，請選擇 **File** (檔案)、**Save** (儲存)。)
```
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] - Idle** ([新增] - 閒置) 標籤上，選擇 **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/zh_tw/cloud9/latest/user-guide/images/ide-nodejs-simple.png)
## 步驟 4：在 Node.js 中安裝和設定適用於 JavaScript 的 AWS SDK
在 中執行 Node.js 指令碼時 AWS Cloud9，您可以選擇適用於 JavaScript 的 AWS SDK 第 3 版 (V3) 和適用於 JavaScript 的較舊 AWS SDK 第 2 版 (V2)。與 V2 一樣，V3 讓您能夠輕鬆地使用 Amazon Web Services 工作，但此版本已經以 TypeScript 撰寫，並且增加了數個呼聲不斷的功能，例如模組化套件。
------
#### [ AWS SDK for JavaScript (V3) ]
您可以增強此範例，以使用 Node.js 中適用於 JavaScript 的 AWS SDK 來建立 Amazon S3 儲存貯體、列出可用的儲存貯體，然後刪除您剛建立的儲存貯體。
在此步驟中，您會以 Node.js 安裝並設定 JavaScript 的 AWS SDK 中的 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 和適用於 JavaScript 的 AWS SDK (V3) 的資訊，請參閱*AWS 《適用於 JavaScript 的 SDK 開發人員指南 (V3)*》中的 [ Node.js 入門](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/getting-started-nodejs.html#getting-started-nodejs-setup-structure)。
在 Node.js 中安裝適用於 JavaScript 的 AWS SDK 之後，您必須在環境中設定登入資料管理。Node.js 中適用於 JavaScript 的 AWS SDK 需要這些登入資料才能與服務 AWS 互動。
**在 Node.js 中安裝適用於 JavaScript 的 AWS SDK**
使用 npm 執行 **`install`** 命令。
```
npm install @aws-sdk/client-s3
```
如需詳細資訊，請參閱 *適用於 JavaScript 的 AWS SDK 開發人員指南*中的[安裝 JavaScript 的 SDK](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-up.html#installing-jssdk)。
**在環境中設定憑證管理**
每次使用 Node.js 中適用於 JavaScript 的 AWS SDK 來呼叫 AWS 服務時，您必須隨呼叫提供一組登入資料。這些憑證會判斷 Node.js 的 JavaScript 專用 AWS SDK 是否具備適當許可，能夠發出該次呼叫。若登入資料未涵蓋適當許可，呼叫即會失敗。
在此步驟中，您會在環境中存放您的憑證。若要這麼做，請遵循 [AWS 服務 從 中的環境呼叫 AWS Cloud9](credentials.md) 中的指示，然後返回本主題。
如需詳細資訊，請參閱 *適用於 JavaScript 的 AWS SDK 開發人員指南*中的[以 Node.js 設定憑證](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/setting-credentials-node.html)。
------
#### [ AWS SDK for JavaScript (V2) ]
您可以增強此範例，以使用 Node.js 中適用於 JavaScript 的 AWS SDK 來建立 Amazon S3 儲存貯體、列出可用的儲存貯體，然後刪除您剛建立的儲存貯體。
在此步驟中，您會在 Node.js 中安裝和設定適用於 JavaScript 的 AWS SDK，這可讓您透過 JavaScript 程式碼與 Amazon S3 等 AWS 服務互動。在 Node.js 中安裝適用於 JavaScript 的 AWS SDK 之後，您必須在環境中設定登入資料管理。Node.js 中適用於 JavaScript 的 AWS SDK 需要這些登入資料才能與 AWS 服務互動。
**在 Node.js 中安裝適用於 JavaScript 的 AWS SDK**
使用 npm 執行 **`install`** 命令。
```
npm install aws-sdk
```
如需詳細資訊，請參閱 *適用於 JavaScript 的 AWS SDK 開發人員指南*中的[安裝 JavaScript 的 SDK](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/installing-jssdk.html)。
**在環境中設定憑證管理**
每次使用 Node.js 中適用於 JavaScript 的 AWS SDK 來呼叫 AWS 服務時，您必須隨呼叫提供一組登入資料。這些憑證會判斷 Node.js 的 JavaScript 專用 AWS SDK 是否具備適當許可，能夠發出該次呼叫。若登入資料未涵蓋適當許可，呼叫即會失敗。
在此步驟中，您會在環境中存放您的憑證。若要這麼做，請遵循 [AWS 服務 從 中的環境呼叫 AWS Cloud9](credentials.md) 中的指示，然後返回本主題。
如需詳細資訊，請參閱 *適用於 JavaScript 的 AWS SDK 開發人員指南*中的[以 Node.js 設定憑證](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] - Idle** ([新增] - 閒置) 標籤上，選擇 **Runner: Auto** (執行器: 自動)，然後選擇 **Node.js**。
1. 如果您使用的是適用於 JavaScript 的 AWS SDK (V3)，適用於**命令**類型 `s3.js`。如果您使用的是適用於 Javascript (v2) 的 AWS SDK`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. 選擇 **Run** (執行) 按鈕，然後對照您的輸出。
```
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：安裝和設定 適用於 PHP 的 AWS SDK](#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 開發環境。**本範例假設您已具備 EC2 環境，且該環境已連線到執行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 執行個體。如果您有不同類型的環境或作業系統，您可能需要依照此範例的說明來設定相關工具。如需詳細資訊，請參閱[在 中建立環境 AWS Cloud9](create-environment.md)。
+ **您已開啟現有環境的 AWS Cloud9 IDE。**當您開啟環境時，請在 Web 瀏覽器中 AWS Cloud9 開啟該環境的 IDE。如需詳細資訊，請參閱[在 中開啟環境 AWS Cloud9](open-environment.md)。
## 步驟 1：安裝必要工具
在此步驟中，您將安裝 PHP，這是執行此範例的必要工具。
**注意**
下列程序只會安裝 PHP。若要安裝 Apache Web 伺服器和 MySQL 資料庫等相關工具，請參閱《[Amazon EC2 使用者指南》中的教學課程：在 Amazon Linux 上安裝 LAMP Web 伺服器](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-LAMP.html)。 *Amazon EC2 *
1. 在 IDE AWS Cloud9 的終端機工作階段中，執行 **`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 網站上的 [Installation and Configuration](http://php.net/manual/en/install.php)。
## 步驟 2：新增程式碼
在 AWS Cloud9 IDE 中，建立具有此內容的檔案，並使用名稱 儲存檔案`hello.php`。(若要建立檔案，請在選單列上，選擇 **File** (檔案)、**New File** (新增檔案)。若要儲存檔案，請選擇 **File** (檔案)、**Save** (儲存)，為 **Filename** (檔案名稱) 輸入 `hello.php`，然後選擇 **Save** (儲存)。)
```
```
**注意**
上述程式碼未依賴任何外部檔案。不過，如果您曾經在 檔案中包含或要求其他 PHP 檔案，而且 AWS Cloud9 想要在輸入時使用這些檔案完成程式碼，請在**偏好設定**中開啟**專案、PHP 支援、啟用 PHP 程式碼完成**設定，然後將這些檔案的路徑新增至**專案、PHP 支援、PHP 完成包含路徑**設定。(若要檢視及變更偏好設定，請從選單列選擇 **AWS Cloud9、Preferences** (偏好設定))。
## 步驟 3：執行程式碼
1. 在 AWS Cloud9 IDE 的選單列中，選擇**執行**、**執行組態**、**新執行組態**。
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/zh_tw/cloud9/latest/user-guide/images/ide-php-simple.png)
## 步驟 4：安裝和設定 適用於 PHP 的 AWS SDK
您可以增強此範例，以使用 適用於 PHP 的 AWS SDK 建立 Amazon S3 儲存貯體、列出可用的儲存貯體，然後刪除您剛建立的儲存貯體。
在此步驟中，您會安裝並設定 適用於 PHP 的 AWS SDK，這可讓您透過 PHP 程式碼與 Amazon S3 等 AWS 服務互動。在安裝 之前 適用於 PHP 的 AWS SDK，您應該安裝 [Composer](https://getcomposer.org/)。安裝 之後 適用於 PHP 的 AWS SDK，您必須在環境中設定登入資料管理。 適用於 PHP 的 AWS SDK 需要這些登入資料才能與 AWS 服務互動。
### 安裝 Composer
搭配無訊息 (**) 執行 `curl` ** `-s` 命令，並顯示錯誤 (`-S`) 選項，以透過管線將 Composer 安裝程式放入 PHP 封存檔 (PHAR) (依慣例命名為 `composer.phar`)。
```
curl -sS https://getcomposer.org/installer | php
```
### 安裝 適用於 PHP 的 AWS SDK
對於 Ubuntu Server，安裝 Composer 安裝 適用於 PHP 的 AWS SDK時所需的額外套件。
```
sudo apt install -y php-xml php-curl
```
如為 Amazon Linux 或 Ubuntu Server，請使用 **php** 命令執行 Composer 安裝程式來安裝 適用於 PHP 的 AWS SDK。
```
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
```
如需詳細資訊，請參閱 *適用於 PHP 的 AWS SDK 開發人員指南*中的[安裝](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/installation.html)。
### 在環境中設定憑證管理
每次使用 適用於 PHP 的 AWS SDK 來呼叫 AWS 服務時，您必須隨呼叫提供一組登入資料。這些登入資料會判斷 是否 適用於 PHP 的 AWS SDK 具有進行該呼叫的適當許可。如果登入資料未涵蓋適當許可，呼叫即會失敗。
在此步驟中，您會在環境中存放您的憑證。若要這麼做，請遵循 [AWS 服務 從 中的環境呼叫 AWS Cloud9](credentials.md) 中的指示，然後返回本主題。
如需詳細資訊，請參閱 *適用於 PHP 的 AWS SDK 開發人員指南*中[基本用量](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 的選單列中，選擇**執行**、**執行組態**、**新執行組態**。
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. 選擇 **Run** (執行) 按鈕，然後對照您的輸出。
```
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 中的適用於 Ruby 的 SDK AWS Cloud9
如需 AWS Cloud9 搭配適用於 Ruby 的 AWS SDK 使用 的相關資訊，請參閱《[適用於 Ruby 的 AWS SDK 開發人員指南》中的搭配適用於 Ruby 的 SDK 使用 AWS Cloud9](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/cloud9-ruby.html) 。 *AWS *
**注意**
遵循本教學課程可能會向您的 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：安裝和設定 適用於 Go 的 AWS SDK](#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 開發環境。**本範例假設您已具備 EC2 環境，且該環境已連線到執行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 執行個體。如果您有不同類型的環境或作業系統，您可能需要依照此範例的說明來設定相關工具。如需詳細資訊，請參閱[在 中建立環境 AWS Cloud9](create-environment.md)。
+ **您已開啟現有環境的 AWS Cloud9 IDE。**當您開啟環境時，請在 Web 瀏覽器中 AWS Cloud9 開啟該環境的 IDE。如需詳細資訊，請參閱[在 中開啟環境 AWS Cloud9](open-environment.md)。
## 步驟 1：安裝必要工具
在此步驟中，您將安裝和設定 Go，這是執行此範例的必要工具。
1. 在 IDE AWS Cloud9 的終端機工作階段中，執行 **`go version`**命令以確認是否已安裝 Go。(若要啟動新終端機工作階段，請在選單列上，選擇 **Window** (視窗)、**New Terminal** (新增終端機)。如果成功，則輸出應該包含 Go 版本號碼。否則，應該會輸出錯誤訊息。若 Go 已安裝，請跳至[步驟 2：新增程式碼](#sample-go-code)。
1. 執行 **`yum update`** (適用於 Amazon Linux) 或 **`apt update`** (適用於 Ubuntu Server) 命令，協助確保已安裝最新安全性更新和錯誤修正。
針對 Amazon Linux：
```
sudo yum -y update
```
針對 Ubuntu Server：
```
sudo apt update
```
1. 若要安裝 Go，請逐一執行這些命令。
```
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 Programming Language 網站上的 [Downloads](https://golang.org/dl/)。
1. 將 Go 二進位檔的路徑新增至 `PATH` 環境變數，如下所示。
1. 開啟您的 shell 描述檔檔案 (例如，`~/.bashrc`) 以進行編輯。
1. 在這行程式碼的結尾，輸入下列程式碼，讓程式碼現在如下所示。
```
PATH=$PATH:/usr/local/go/bin
```
1. 儲存檔案。
1. 取得 `~/.bashrc` 檔案，讓終端機現在可以找到您剛剛參考的 Go 二進位檔。
```
. ~/.bashrc
```
1. 執行 ** `go version` ** 命令，以確認現在已成功安裝和設定 Go。如果成功，輸出會包含 Go 版本號碼。
## 步驟 2：新增程式碼
在 AWS Cloud9 IDE 中，建立具有此內容的檔案，並使用名稱 儲存檔案`hello.go`。(若要建立檔案，請在選單列上選擇 **File** (檔案)、**New File** (新增檔案)。若要儲存檔案，請選擇 **File** (檔案)、**Save** (儲存)。)
```
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 的選單列中，選擇**執行**、**執行組態**、**新執行組態**。
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** (另存新檔)，然後儲存檔案至 `/.c9/runners` 資料夾並命名為 `Go.run`。
在 **[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/zh_tw/cloud9/latest/user-guide/images/ide-go-simple.png)
1. 選擇 **Run** (執行) 按鈕，然後對照您的輸出。
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## 步驟 4：安裝和設定 適用於 Go 的 AWS SDK
您可以增強此範例，以使用 適用於 Go 的 AWS SDK 建立 Amazon S3 儲存貯體、列出可用的儲存貯體，然後刪除您剛建立的儲存貯體。
在此步驟中，您會安裝並設定 適用於 Go 的 AWS SDK，這可讓您透過 Go 程式碼與 Amazon S3 等 AWS 服務互動。安裝 適用於 Go 的 AWS SDK前，您必須設定 `GOPATH`環境變數。安裝 適用於 Go 的 AWS SDK 並設定 `GOPATH` 環境變數之後，您必須在環境中設定憑證管理。 適用於 Go 的 AWS SDK 需要這些登入資料才能與 AWS 服務互動。
### 設定 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`。
### 安裝 適用於 Go 的 AWS SDK
執行 **`go get`**命令，指定 適用於 Go 的 AWS SDK 來源的位置。
```
go get -u github.com/aws/aws-sdk-go/...
```
Go 會將 適用於 Go 的 AWS SDK 來源安裝到`GOPATH`環境變數指定的位置，這是您環境中的`go`資料夾。
### 在環境中設定憑證管理
每次使用 適用於 Go 的 AWS SDK 來呼叫 AWS 服務時，您必須隨呼叫提供一組登入資料。這些登入資料會判斷 是否 適用於 Go 的 AWS SDK 具有進行該呼叫的適當許可。如果登入資料未涵蓋適當許可，呼叫即會失敗。
在此步驟中，您會在環境中存放您的憑證。若要這麼做，請遵循 [AWS 服務 從 中的環境呼叫 AWS Cloud9](credentials.md) 中的指示，然後返回本主題。
如需詳細資訊，請參閱 *適用於 Go 的 AWS SDK 開發人員指南*中的[指定憑證](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 的選單列中，選擇**執行**、**執行組態**、**新執行組態**。
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. 選擇 **Run** (執行) 按鈕，然後對照您的輸出。
```
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 中安裝和設定適用於 JavaScript 的 AWS SDK](#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 開發環境。**本範例假設您已具備 EC2 環境，且該環境已連線到執行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 執行個體。如果您有不同類型的環境或作業系統，您可能需要依照此範例的說明來設定相關工具。如需詳細資訊，請參閱[在 中建立環境 AWS Cloud9](create-environment.md)。
+ **您已開啟現有環境的 AWS Cloud9 IDE。**當您開啟環境時，請在 Web 瀏覽器中 AWS Cloud9 開啟該環境的 IDE。如需詳細資訊，請參閱[在 中開啟環境 AWS Cloud9](open-environment.md)。
## 步驟 1：安裝必要工具
在此步驟中，您使用節點套件管理工具 (**`npm`**) 安裝 TypeScript。若要安裝 **`npm`**，請使用節點套件管理工具 (**`nvm`**)。如果沒有 **`nvm`**，請先在此步驟中安裝它。
1. 在 IDE AWS Cloud9 的終端機工作階段中，使用 **`--version`**選項執行命令列 TypeScript 編譯器，以確認是否已安裝 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` ** 是一種簡單的 Bash shell 指令碼，適用於安裝和管理 Node.js 版本。如需詳細資訊，請參閱 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. 執行 以安裝最新版本的 Node.js ** `nvm` **16。 (** `npm` ** 包含在 Node.js 中。)
```
nvm install v16
```
1. 執行 Node.js 命令列版本搭配 **`--version`** 選項，確認已安裝 Node.js。
```
node --version
```
1. 以 ** `--version` ** 選項執行 ** `npm` **，確認已安裝 ** `npm` **。
```
npm --version
```
1. 執行 **`npm`** 搭配 **`-g`** 選項，安裝 TypeScript。這個動作會在環境中將 TypeScript 安裝為全域套件。
```
npm install -g typescript
```
1. 執行命令列 TypeScript 編譯器搭配 **`--version`** 選項，確認 TypeScript 已安裝。
```
tsc --version
```
## 步驟 2：新增程式碼
1. 在 AWS Cloud9 IDE 中，建立名為 的檔案`hello.ts`。(若要建立檔案，請在選單列上選擇 **File** (檔案)、**New File** (新增檔案)。若要儲存檔案，請選擇 **File** (檔案)、**Save** (儲存)。)
1. 在 IDE 的終端機中，從與 `hello.ts` 檔案的相同目錄執行 **`npm`** 以安裝 `@types/node` 程式庫。
```
npm install @types/node
```
這樣會在與 `node_modules/@types/node` 檔案相同的目錄中新增 `hello.ts` 資料夾。這個新資料夾包含了 TypeScript 在此程序稍後需要的 Node.js 類型定義 (針對將加入 `hello.ts` 檔案中的 `console.log` 和 `process.argv` 屬性)。
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] - Idle** ([新增] - 閒置) 標籤上，選擇 **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/zh_tw/cloud9/latest/user-guide/images/ide-nodejs-simple.png)
**注意**
除了在 IDE 中建立新的執行組態，您也可以從終端機執行命令 **`node hello.js 5 9`** 來執行此程式碼。
## 步驟 4：在 Node.js 中安裝和設定適用於 JavaScript 的 AWS SDK
您可以增強此範例，以使用 Node.js 中適用於 JavaScript 的 AWS SDK 來建立 Amazon S3 儲存貯體、列出可用的儲存貯體，然後刪除您剛建立的儲存貯體。
在此步驟中，您會在 Node.js 中安裝和設定適用於 JavaScript 的 AWS SDK。開發套件提供便捷的方式，可讓您透過 JavaScript 程式碼與 Amazon S3 等 AWS 服務互動。在 Node.js 中安裝適用於 JavaScript 的 AWS SDK 之後，您必須在環境中設定登入資料管理。開發套件需要這些登入資料才能與 AWS 服務互動。
### 在 Node.js 中安裝適用於 JavaScript 的 AWS SDK
在 IDE AWS Cloud9 的終端機工作階段中，從與 `hello.js` 檔案相同的目錄執行 [步驟 3：執行程式碼](#sample-typescript-run)，**`npm`**以在 Node.js 中安裝適用於 JavaScript 的 AWS SDK。
```
npm install aws-sdk
```
此命令會新增數個資料夾到 [步驟 3：執行程式碼](#sample-typescript-run) 中的 `node_modules` 資料夾。這些資料夾包含 Node.js 中適用於 JavaScript 的 AWS SDK 的原始程式碼和相依性。如需詳細資訊，請參閱 *適用於 JavaScript 的 AWS SDK 開發人員指南*.中的[安裝 JavaScript 的 SDK](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/installing-jssdk.html)
### 在環境中設定憑證管理
每次在 Node.js 中使用適用於 JavaScript 的 AWS SDK 來呼叫 AWS 服務時，您必須隨呼叫提供一組登入資料。這些登入資料會判斷 Node.js 中適用於 JavaScript 的 AWS SDK 是否具有進行該呼叫的適當許可。如果登入資料未涵蓋適當許可，呼叫即會失敗。
在此步驟中，您會在環境中存放您的憑證。若要這麼做，請遵循 [AWS 服務 從 中的環境呼叫 AWS Cloud9](credentials.md) 中的指示，然後返回本主題。
如需詳細資訊，請參閱 *適用於 JavaScript 的 AWS SDK 開發人員指南*中的[以 Node.js 設定憑證](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. 從 IDE AWS Cloud9 中的終端機，在與 `s3.ts` 檔案相同的目錄中，透過執行**`npm`**兩次以非同步方式啟用程式碼來呼叫 Amazon S3 操作，以安裝 TypeScript 的非同步程式庫，並再次為 JavaScript 安裝非同步程式庫。
```
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 中 JavaScript 的 AWS SDK、非同步程式庫和一組 ECMAScript 6 (ES6) 程式庫檔案，將`s3.ts`檔案中的 TypeScript 程式碼轉換為名為 之檔案中的同等 JavaScript 程式碼`s3.js`。
1. 在 **Environment (環境)** 視窗中開啟 `s3.js` 檔案。
1. 在選單列上，選擇 **Run** (執行)、**Run Configurations** (執行組態)、**New Run Configuration** (新增執行組態)。
1. 在 **[New] - Idle** ([新增] - 閒置) 標籤上，選擇 **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
本教學課程說明如何將 AWS Cloud9 SSH 開發環境連接至 Amazon EC2 中 Amazon Linux 執行個體內執行中的 Docker 容器。這可讓您使用 AWS Cloud9 IDE 來處理 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 執行個體。**此範例假設您的帳戶中已有執行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 執行個體 AWS 。若要啟動 Amazon EC2 執行個體，請參閱[啟動 Linux 虛擬機器](https://aws.amazon.com/getting-started/tutorials/launch-a-virtual-machine/)。在該精靈的 **Choose an Amazon Machine Image (AMI)** (選擇 Amazon Machine Image (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 後，您會在執行個體上執行它。
1. 使用 SSH 用戶端 (例如 **`ssh`** 公用程式或 PuTTY) 來連接至執行中的 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. 若要這樣做，請以 ** `install` ** 動作執行 ** `yum` ** 或 ** `apt` ** 命令，並指定要安裝的 ** `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. 使用 AWS Cloud9 開啟和編輯`/tmp/Dockerfile`檔案。
```
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 公有金鑰。若要這樣做，舉例來說，可以透過執行 `Dockerfile` `authorized_keys` ** 命令，在與 `touch` 檔案所在的相同目錄中，建立名為 ** 的檔案。
```
sudo touch /tmp/authorized_keys
```
1. 將 AWS Cloud9 SSH 公有金鑰新增至 `authorized_keys` 檔案。若要取得 AWS Cloud9 SSH 公有金鑰，請執行下列動作：
1. 在 https：//[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** (為環境命名) 頁面的 **Name** (名稱) 內，輸入環境的名稱。(此處的名稱並不重要。您稍後還會選擇不同的名稱。)
1. 選擇 **下一個步驟**。
1. 對於 **Environment type (環境類型)**，選擇 **Connect and run in remote server (SSH) (連線並在遠端伺服器中執行 (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. 以 ** `build` ** 動作執行 ** `docker` ** 命令，並將標籤 `cloud9-image:latest` 新增到影像，並指定要使用的 `Dockerfile` 檔案路徑，藉此建置影像。
```
sudo docker build -t cloud9-image:latest /tmp
```
如果成功，建置輸出的最後兩行會顯示 `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 容器，在執行個體上執行的 ** `docker` ** 命令搭配 ** `run` ** 動作和以下選項。
```
sudo docker run -d -it --expose 9090 -p 0.0.0.0:9090:22 --name cloud9 cloud9-image:latest
```
+ `-d` 會在分離模式中執行容器，會在用來執行容器 (在這個範例中，也就是 SSH 用戶端) 的根程序結束時便跟著結束。
+ `-it` 會使用分配的 pseudo-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. 登入執行中容器。若要這樣做，請執行 ** `docker` ** 命令並使用 ** `exec` ** 動作和下列選項。
```
sudo docker exec -it cloud9 bash
```
+ `-it` 會使用分配的 pseudo-TTY 來執行容器，並讓 STDIN 保持開放 (如果未連接容器)。
+ `cloud9` 是執行中容器之可供人類讀取的名稱。
+ `bash` 在執行中容器中開始標準 shell。
如果成功，終端提示變更會顯示容器的登入使用者名稱和容器 ID。
**注意**
如果您想要登出執行中的容器，執行 ** `exit` ** 命令。終端提示會變回會顯示執行個體的登入使用者名稱和執行個體的私有 DNS。容器仍應執行中。
1. 對於您要在登入後從中 AWS Cloud9 啟動的容器上的目錄，將其存取許可設定為 ** `rwxr-xr-x` **。這表示為擁有者設定讀取-寫入-執行許可、為群組設定讀取-執行許可，並為其他人設定讀取-執行許可。例如，如果目錄的路徑是 `~`，您可以在執行中容器中執行 **`chmod`** 命令，以在目錄上設定這些許可，如下所示。
```
sudo chmod u=rwx,g=rx,o=rx ~
```
1. 請記下在包含 Node.js 二進位執行容器上的目錄路徑，因為您在[步驟 4：建立環境](#sample-docker-env)時會需要此資訊。如果您不確定此路徑為何，對執行中容器執行以下命令來取得此資訊。
```
which node
```
## 步驟 4：建立環境
在此步驟中，您會使用 AWS Cloud9 建立 AWS Cloud9 SSH 開發環境，並將其連接至執行中的 Docker 容器。在 AWS Cloud9 建立環境後，它會顯示 AWS Cloud9 IDE，讓您可以開始使用容器中的檔案和程式碼。
您可以使用 AWS Cloud9 主控台建立 AWS Cloud9 SSH 開發環境。您不能使用 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 雲端 運算執行個體，請參閱下列一或多個資源：
對於 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. 登入 AWS Cloud9 主控台，網址為 https：//[https://console.aws.amazon.com/cloud9/](https://console.aws.amazon.com/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/zh_tw/cloud9/latest/user-guide/images/consolas_region_new_UX.png)
1. 如果這是您第一次建立開發環境，畫面會顯示歡迎頁面。在**新增 AWS Cloud9 環境**面板中，選擇**建立環境**。
如果您先前已建立開發環境，也可以展開畫面左側的窗格。選擇 **Your environments** (您的環境)，然後選擇 **Create environment** (建立環境)。
在 **welcome** (歡迎) 頁面中：
![\[如顯示歡迎頁面，請選擇建立環境按鈕\]](http://docs.aws.amazon.com/zh_tw/cloud9/latest/user-guide/images/create_welcome_env_new_UX.png)
或者在 **Your environments** (您的環境) 頁面中：
![\[如未顯示歡迎頁面，請選擇建立環境按鈕\]](http://docs.aws.amazon.com/zh_tw/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 執行個體** – 啟動 AWS Cloud9 可透過 SSH 直接連線至 的 Amazon EC2 執行個體。
+ ** 現有運算 ** – 啟動不需要任何開放傳入連接埠的 Amazon EC2 執行個體。透過 AWS Cloud9 連線至執行個體[AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager.html)。
+ 如果您選取 **Existing compute** (現有運算) 選項，系統會建立服務角色和 IAM 執行個體描述檔，以允許 Systems Manager 代表您與 EC2 執行個體互動。您可以在界面中繼續往下拉到 **Service role and instance profile for Systems Manager access** (Systems Manager 存取的服務角色和執行個體描述檔) 區塊檢視兩者的名稱。如需詳細資訊，請參閱[使用 存取無輸入 EC2 執行個體 AWS Systems Manager](ec2-ssm.md)。
**警告**
為您的環境建立 EC2 執行個體可能會對您的 AWS 帳戶 Amazon EC2 產生費用。使用 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 path** (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/zh_tw/cloud9/latest/user-guide/images/cloud9-ide-open.png)
若無法建立帳戶， AWS Cloud9 主控台上方會出現紅色閃爍列。由於 Web 瀏覽器、 AWS 存取許可、執行個體或關聯的網路發生問題，您的帳戶可能無法建立 。您可以在 [AWS Cloud9 疑難排解區段](troubleshooting.md#troubleshooting-env-loading)找到可行修正方法，解決造成帳戶無法使用的問題。
**注意**
如果您的環境使用代理存取網際網路，您必須提供代理的詳細資訊給 ， AWS Cloud9 以便安裝相依性。如需詳細資訊，請參閱[無法安裝相依性](troubleshooting.md#proxy-failed-dependencies)。
## 步驟 5：執行程式碼
在此步驟中，您可以使用 AWS Cloud9 IDE 在執行中的 Docker 容器內執行範例應用程式。
1. 為執行中的容器顯示 AWS Cloud9 IDE 後，啟動範例聊天伺服器。若要這麼做，在 **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 容器從執行個體中移除。若要這樣做，請以 ** `stop` ** 和 ** `rm` ** 在執行個體上執行 ** `docker` ** 命令，停止動作和容器的人類可識讀名稱。
```
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。若要這樣做，請以 ** `remove` ** 動作在執行個體上執行 ** `yum` ** 命令，並指定要取消安裝的 ** `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 開發人員指南》中的 RoboMaker 入門](https://docs.aws.amazon.com/robomaker/latest/dg/getting-started.html)。 *AWS RoboMaker * 本教學課程使用 AWS Cloud9 來修改、建置和綁定範例機器人應用程式。