AWS Cloud9 不再向新客户提供。 AWS Cloud9 的现有客户可以继续正常使用这项服务。[了解详情](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)
本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 的教程 AWS Cloud9
你是新手 AWS Cloud9吗？ 在 [入门：基本教程](tutorials-basic.md) 中浏览 IDE 相关信息。
尝试使用这些教程和示例代码，使用各种编程语言和 AWS 服务 AWS Cloud9 来增加您的知识和信心。
**Topics**
+ [AWS CLI 和 aws-shell 教程](sample-aws-cli.md)
+ [AWS CodeCommit 教程](sample-codecommit.md)
+ [Amazon DynamoDB 教程](sample-dynamodb.md)
+ [AWS CDK 教程](sample-cdk.md)
+ [LAMP 教程](sample-lamp.md)
+ [WordPress 教程](sample-wordpress.md)
+ [Java 教程](sample-java.md)
+ [C\$1\$1 教程](sample-cplusplus.md)
+ [Python 教程](sample-python.md)
+ [.NET 教程](sample-dotnetcore.md)
+ [Node.js 教程](sample-nodejs.md)
+ [PHP 教程](sample-php.md)
+ [Ruby](tutorial-ruby.md)
+ [Go 教程](sample-go.md)
+ [TypeScript 教程](sample-typescript.md)
+ [Docker 教程](sample-docker.md)
+ [相关教程](#samples-additonal)
# AWS CLI 还有 aws-shell 教程 AWS Cloud9
以下教程允许您在 AWS Cloud9 开发环境中设置 AWS Command Line Interface (AWS CLI)、aws-shell 或两者。 AWS CLI 和 aws-shell 是统一的工具，它们为与的所有部分进行交互提供了一致的界面。 AWS您可以使用 AWS CLI 代替 AWS 管理控制台 来快速运行要与之交互的命令 AWS，其中一些命令可以与 AWS CLI 或一起运行 AWS CloudShell。
有关更多信息 AWS CLI，请参阅《[AWS Command Line Interface 用户指南》](https://docs.aws.amazon.com/cli/latest/userguide/)。对于 aws-shell，请参阅以下资源：
+ 网站上的 [aws-shell](https://github.com/awslabs/aws-shell) GitHub
+ pip 网站上的 [aws-shell](https://pypi.python.org/pypi/aws-shell)
有关可与之交互的命令的 AWS CLI 列表 AWS，请参阅《[AWS CLI 命令参考](https://docs.aws.amazon.com/cli/latest/reference/)》。除了启动不带`aws`前缀的命令外 AWS CloudShell，您还可以使用相同的命令。
创建此样本可能会导致向您的 AWS 账户收取费用。其中包括可能对 Amazon EC2 和 Amazon S3 等服务收取的费用。有关更多信息，请参阅 [Amazon EC2 定价](https://aws.amazon.com/ec2/pricing/)和 [Amazon S3 定价](https://aws.amazon.com/s3/pricing/)。
**Topics**
+ [先决条件](#sample-aws-cli-prereqs)
+ [步骤 1：在您的环境中安装 AWS CLI、aws-shell 或两者兼而有之](#sample-aws-cli-install)
+ [步骤 2：在环境中设置凭证管理](#sample-aws-cli-creds)
+ [步骤 3：在您的环境中使用 AWS CLI 或 aws-shell 运行基本命令](#sample-aws-cli-run)
+ [步骤 4：清除](#sample-aws-cli-clean-up)
## 先决条件
在使用此示例之前，请确保您的设置满足以下要求：
+ **您必须拥有现有 AWS Cloud9 的 EC2 开发环境。**本示例假设您已经有连接到运行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 实例的 EC2 环境。如果您有不同类型的环境或操作系统，可能需要按照本示例的说明来设置相关的工具。有关更多信息，请参阅 [在中创建环境 AWS Cloud9](create-environment.md)。
+ **您已经打开了现有环境的 AWS Cloud9 IDE。**打开环境时，会在 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)。这是因为已经安装在 EC2 环境中，并且已经在该环境中设置了一组 AWS 访问证书。 AWS CLI 有关更多信息，请参阅 [AWS 托管的临时证书](security-iam.md#auth-and-access-control-temporary-managed-credentials)。
如果您不使用 EC2 环境，请执行以下操作安装 AWS CLI：
1. 打开环境后，在 IDE 中检查 AWS CLI 是否已安装。在终端中运行 **`aws --version`** 命令。（要开始新的终端会话，请在菜单栏上依次选择 **Window（窗口）**> **New Terminal（新建终端）**。） 如果安装了，则会显示版本号，其中包含诸如 Python 的版本号和您的 Amazon EC2 实例或您自己的服务器的操作系统版本号之类的信息。 AWS CLI 如果 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 是否具有进行该调用的相应权限。如果凭证没有包括合适的权限，调用将失败。
如果您使用的是 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. 创建存储桶。使用带有 aw **`aws s3 mb`**s-shell 的 AWS CLI 或**`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-**`s3 ls`**shell 运行命令。此时将显示您的可用存储桶列表。
1. 删除 存储桶。使用**`aws s3 rb`**命令 AWS CLI 或使用 aws-shell 运行**`s3 rb`**命令，提供要删除的存储桶的名称。
```
aws s3 rb s3://cloud9-123456789012-bucket # For the AWS CLI.
s3 rb s3://cloud9-123456789012-bucket # For the aws-shell.
```
要确认存储桶是否已删除，请使用再次运行该**`aws s3 ls`**命令， AWS CLI 或者使用 aws-s **`s3 ls`**hell 再次运行该命令。已删除的存储桶的名称应不再显示在列表中。
**注意**
如果您要继续使用存储桶，则无需删除它。有关更多信息，请参阅 *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 用户指南》*和《[AWS CLI 命令参考](https://docs.aws.amazon.com/cli/latest/reference/)》中的 “[使用 Amazon Web Services](https://docs.aws.amazon.com/cli/latest/userguide/chap-working-with-services.html)”。要继续试用 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 是一项源代码控制服务，可用于在中私下存储和管理Git存储库 AWS 云。有关的更多信息 CodeCommit，请参阅《[AWS CodeCommit 用户指南》](https://docs.aws.amazon.com/codecommit/latest/userguide/)。
按照本教程并创建此示例可能会导致向您收取费用 AWS 账户。这些费用包括 Amazon EC2 等服务可能产生的费用 CodeCommit。有关更多信息，请参阅 [Amazon EC2 定价](https://aws.amazon.com/ec2/pricing/)和 [AWS CodeCommit 定价](https://aws.amazon.com/codecommit/pricing/)。
+ [先决条件](#sample-codecommit-prereqs)
+ [步骤 1：设置具有所需访问权限的 IAM 组](#sample-codecommit-permissions)
+ [步骤 2：在中创建存储库 AWS CodeCommit](#sample-codecommit-create-repo)
+ [步骤 3：将您的环境连接到远程存储库](#sample-codecommit-connect-repo)
+ [步骤 4：将远程存储库克隆到您的环境](#sample-codecommit-clone-repo)
+ [步骤 5：向存储库添加文件](#sample-codecommit-add-files)
+ [步骤 6：清除](#sample-codecommit-clean-up)
## 先决条件
在使用此示例之前，请确保您的设置满足以下要求：
+ **您必须拥有现有 AWS Cloud9 的 EC2 开发环境。**本示例假设您已经有连接到运行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 实例的 EC2 环境。如果您有不同类型的环境或操作系统，可能需要按照本示例的说明来设置相关的工具。有关更多信息，请参阅 [在中创建环境 AWS Cloud9](create-environment.md)。
+ **您已经打开了现有环境的 AWS Cloud9 IDE。**打开环境时，会在 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 Command Line Interface (AWS CLI)](#sample-codecommit-permissions-cli) 完成此步骤。
### 使用控制台设置具有所需访问权限的 IAM 组
1. 如果您尚未登录 AWS 管理控制台，请登录。
对于该步骤，我们建议使用您的 AWS 账户中的管理员用户的凭证登录。如果您无法执行此操作，请咨询您的 AWS 账户 管理员。
1. 打开 IAM 控制台。为此，请在控制台的导航栏中选择 **Service（服务）**。然后，选择 **IAM**。
1. 选择 **Groups（组）**。
1. 选择组名。
1. 在 **Permissions（权限）**选项卡中，在 **Manged Policies（托管式策略）**处，选择 **Attach Policy（附加策略）**。
1. 在策略名称列表中，选中以下框之一：
+ 选择**AWSCodeCommitPowerUser**即可访问存储库相关资源的所有功能 CodeCommit 和资源。但是，这不允许您删除 CodeCommit 存储库或在其他 AWS 服务（例如 Amazon Events）中创建或删除与仓库相关的资源。 CloudWatch
+ 要完全控制中的 CodeCommit 存储库和相关资源，请选择**AWSCodeCommitFullAccess**该选项 AWS 账户。这包括可以删除存储库。
如果在列表中看不到任一策略名称，请在 **Filter**（筛选条件）框中输入策略名称以显示它们。
1. 选择**附加策略**。
要查看这些 AWS 托管策略授予群组的访问权限列表，请参阅*AWS CodeCommit 用户指南 AWS CodeCommit*中的[AWS 托管（预定义）策略](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html#managed-policies)。
向前跳至[步骤 2：在中创建存储库 AWS CodeCommit](#sample-codecommit-create-repo)。
### 使用设置具有所需访问权限的 IAM 群组 AWS CLI
运行 IAM `attach-group-policy` 命令，指定群组名称和描述所需访问权限的 AWS 托管策略的 Amazon 资源名称 (ARN)。语法如下所示。
```
aws iam attach-group-policy --group-name MyGroup --policy-arn POLICY_ARN
```
在上述命令中，将 `MyGroup` 替换为组的名称。`POLICY_ARN`替换为 AWS 托管策略的 ARN：
+ `arn:aws:iam::aws:policy/AWSCodeCommitPowerUser`用于访问存储库相关资源的所有功能 CodeCommit 和资源。但是，它不允许您删除 CodeCommit 存储库或在其他 AWS 服务（例如 Amazon Events）中创建或删除与仓库相关的资源。 CloudWatch
+ `arn:aws:iam::aws:policy/AWSCodeCommitFullAccess`以完全控制中的 CodeCommit 存储库和相关资源 AWS 账户。这包括可以删除存储库。
要查看这些 AWS 托管策略授予群组的访问权限列表，请参阅*AWS CodeCommit 用户指南 AWS CodeCommit*中的[AWS 托管（预定义）策略](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 Command Line Interface (AWS CLI)](#sample-codecommit-create-repo-cli) 完成此步骤。
### CodeCommit 使用控制台在中创建存储库
1. 假设您在上一步中 AWS 管理控制台 以管理员用户身份登录，并且您不想使用管理员用户来创建存储库。然后，退出 AWS 管理控制台。
1. 在 [https://console.aws.amazon.com/codeco CodeCommit ](https://console.aws.amazon.com/codecommit) mmit 处打开控制台。
1. 在控制台的导航栏中，使用区域选择器选择要在其中创建存储库的 AWS 区域 （如**美国东部（俄亥俄州）**）。
1. 如果显示欢迎页面，请选择 **Get started（开始使用）**。否则，选择 **Create repository（创建存储库）**。
1. 在 **Create repository**（创建存储库）页面中，为 **Repository name**（存储库名称）键入新存储库的名称（例如 `MyDemoCloud9Repo`）。如果您选择不同的名称，请在本示例中替换为该名称。
1. （可选）对于 **Description**（描述），请键入有关该存储库的信息。例如，您可以输入：`This is a demonstration repository for the AWS Cloud9 sample.`
1. 选择 **Create repository（创建存储库）**。将显示 **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。有关受支持的区域的列表，请参阅**《Amazon Web Services 一般参考》中的 [AWS CodeCommit](https://docs.aws.amazon.com/general/latest/gr/rande.html#codecommit_region)。
如果您选择使用不同的存储库名称，请在本示例中替换为该名称。
## 步骤 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_cn/cloud9/latest/user-guide/sample-codecommit.html) |
| SSH 环境 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/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. CodeCommit 通过运行**`git push`**命令将提交推送到您的远程存储库。
```
git push -u origin master
```
1. 确认是否成功推送这些文件。如果 CodeCommit 控制台尚未打开，请在 [https://console.aws.amazon.com/codeco](https://console.aws.amazon.com/codecommit) mmit 处打开控制台。
1. 在靠近右边缘的顶部导航栏中，选择您创建存储库 AWS 区域 的位置（例如，**美国东部（俄亥俄州）**）。
1. 在**控制面板**页面上，选择 **MyDemoCloud9Repo**。将显示这三个文件。
要继续尝试 CodeCommit 存储库，请参阅《*AWS CodeCommit 用户指南*[》中的 “浏览存储库内容](https://docs.aws.amazon.com/codecommit/latest/userguide/getting-started-cc.html#getting-started-cc-browse)”。
如果您是新手，Git并且不想搞乱 CodeCommit 存储库，请在 T [ry 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)。
# 适用于以下内容的亚马逊 DynamoDB 教程 AWS Cloud9
本教程允许您设置 AWS Cloud9 开发环境以使用 Amazon DynamoDB。
DynamoDB 是一种完全托管式 NoSQL 数据库服务。您可以使用 DynamoDB 创建一个数据库表来存储和检索任意量级的数据，并支持任何级别的请求流量。DynamoDB 自动将表的数据和流量分布到足够数量的服务器上，以处理指定的请求容量和存储的数据量，同时保持一致且快速的性能。有关更多信息，请参阅网站上的[亚马逊 Dyn](https://aws.amazon.com/dynamodb/) amoDB。 AWS
创建此样本可能会导致向您的 AWS 账户收取费用。其中包括可能对 Amazon EC2 和 DynamoDB 等服务收取的费用。有关更多信息，请参阅 [Amazon EC2 定价](https://aws.amazon.com/ec2/pricing/)和 [Amazon DynamoDB 定价](https://aws.amazon.com/dynamodb/pricing/)。
有关其他 AWS 数据库产品的信息，请参阅网站[上的亚马逊关系数据库 (RDS)](https://aws.amazon.com/rds/)、[亚马逊和 ElastiCache亚马逊](https://aws.amazon.com/elasticache/) R [edshift](https://aws.amazon.com/redshift/)。 AWS 另请参阅 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 开发环境。**本示例假设您已经有连接到运行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 实例的 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 CloudShell 示例中的步骤 1 AWS CLI 和](sample-aws-cli.md) 2 进行操作，然后返回本主题。如果您已经在环境中安装并配置了 AWS CloudShell、或两者兼而有之，则无需再次执行此操作。 AWS CLI
1. 通过在您的环境中的终端会话中 AWS CLI运行 DynamoDB **`list-tables`**命令来列出您的现有 DynamoDB 表（如果有），以测试安装和配置、aws-shell 或两者兼而有之。要开始新的终端会话，请在菜单栏上依次选择 **Window (窗口)**、**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`)
要创建表，请在 AWS Cloud9 IDE 的终端会话中运行 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` 表示表的读写容量。对于最大 4 KB 的项目，DynamoDB 允许每秒最多 5 次强一致性读取，或者对于最大 4 KB 的项目，每秒最多 5 次最终一致读数。对于最大 1 KB 的项目，DynamoDB 还允许每秒最多 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` 表示数字属性值。`S` 是字符串属性值。`M` 是映射属性，该属性是一组属性/值对。在使用项目时，您必须指定属性的数据类型。有关其他可用属性数据类型的信息，请参阅 *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 Cloud9 开发环境 AWS Cloud Development Kit (AWS CDK) 中使用。 AWS CDK 是一组软件工具和库，开发人员可以使用它们将 AWS 基础架构组件建模为代码。
AWS CDK 包括 AWS 构造库，您可以使用它来快速解决许多任务 AWS。例如，您可以使用 `Fleet` 构造将代码完全且安全地部署到一队主机。您可以创建自己的构造为架构的各种元素建模，与其他人共享这些构造或将其发布到社区。有关更多信息，请参阅 [AWS Cloud Development Kit 开发人员指南](https://docs.aws.amazon.com/cdk/v2/guide/home.html)。
按照本教程操作并创建此示例可能会对您的 AWS 账户收费。其中包括可能对 Amazon EC2、Amazon SNS 和 Amazon SQS 等服务收取的费用。有关更多信息，请参阅 [Amazon EC2 定价](https://aws.amazon.com/ec2/pricing/)、[Amazon SNS 定价](https://aws.amazon.com/sns/pricing/)和 [Amazon SQS 定价](https://aws.amazon.com/sqs/pricing/)。
**Topics**
+ [先决条件](#sample-cdk-prereqs)
+ [步骤 1：安装所需工具](#sample-cdk-install)
+ [步骤 2：添加代码](#sample-cdk-code)
+ [步骤 3：运行代码](#sample-cdk-run)
+ [步骤 4：清除](#sample-cdk-clean-up)
## 先决条件
在使用此示例之前，请确保您的设置满足以下要求：
+ **您必须拥有现有 AWS Cloud9 的 EC2 开发环境。**本示例假设您已经有连接到运行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 实例的 EC2 环境。如果您有不同类型的环境或操作系统，可能需要按照本示例的说明来设置相关的工具。有关更多信息，请参阅 [在中创建环境 AWS Cloud9](create-environment.md)。
+ **您已经打开了现有环境的 AWS Cloud9 IDE。**打开环境时，会在 Web 浏览器中 AWS Cloud9 打开该环境的 IDE。有关更多信息，请参阅 [在中打开环境 AWS Cloud9](open-environment.md)。
## 步骤 1：安装所需工具
在此步骤中，您将在您的环境中安装运行用 TypeScript 编程语言编写的示例 AWS CDK 所需的所有工具。
1. [节点版本管理器](#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：安装节点版本管理器 (nvm)
1. 在 AWS Cloud9 IDE 的终端会话中，确保安装了最新的安全更新和错误修复。要执行此操作，请运行 **`yum update`**（适用于 Amazon Linux）或 **`apt update`** 命令（适用于 Ubuntu Server）。（要开始新的终端会话，请在菜单栏上依次选择 **Window（窗口）**> **New Terminal（新建终端）**。）
对于 Amazon Linux：
```
sudo yum -y update
```
对于 Ubuntu Server：
```
sudo apt update
```
1. 确认是否已安装 **`nvm`**。为此，请运行带 **`--version`** 选项的 **`nvm`** 命令。
```
nvm --version
```
如果成功，则输出包含 **`nvm`** 版本号，并且您可以向前跳至 [步骤 1.2：安装 Node.js](#sample-cdk-install-nodejs)。
1. 下载并安装 **`nvm`**。要执行此操作，请运行安装脚本。在此示例中，安装了 v0.33.0，但您可以在[此处](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`**。您可用关闭终端会话并重新启动，或者查找包含命令以加载 **`nvm`** 的 `~/.bashrc` 文件。
```
. ~/.bashrc
```
### 步骤 1.2：安装 Node.js
1. 确认是否已安装 Node.js，如果已安装，请确认安装的版本为 16.17.0 或更高版本。**此示例使用 Node.js 16.17.0 进行测试。**要检查结果，请在终端会话仍在 IDE 中打开的情况下，运行带有** `--version` **选项的** `node` **命令。
```
node --version
```
如果已安装 Node.js，则输出将包含版本号。如果该版本号是 v16.17.0，请向前跳至 [步骤 1.3：安装 TypeScript](#sample-cdk-install-typescript)。
1. 安装 Node.js 16，方法是运行带有** `install` ** 操作的** `nvm` **命令。
**注意**
你也可以运行**`nvm install node`**安装 Node.js 的长期支持 (LTS) 版本。 AWS Cloud9 支持追踪 Node.js 的 LTS 版本。
```
nvm install v16
```
1. 开始使用 Node.js 16。为此，请运行** `nvm` **命令与** `alias` **操作、别名的版本号以及要用于该别名的版本，如下所示。
```
nvm alias default 16
```
**注意**
上述命令将 Node.js 16 设置为 Node.js 的默认版本。或者，您可以运行带有** `use` **操作（如** `nvm use 16.17.0` **）而非** `alias` **操作的** `nvm` **命令。不过，**`use`** 操作会导致该版本的 Node.js 仅在当前终端会话运行时运行。
1. 要确认您使用的是 Node.js 16，请再次运行 **`node --version`** 命令。如果已安装正确的版本，则输出将包含版本 v16。
### 步骤 1.3：安装 TypeScript
1. 确认您是否已经 TypeScript 安装。为此，在终端会话仍在 IDE 中处于打开状态的情况下，使用**`--version`**选项运行命令行 TypeScript 编译器。
```
tsc --version
```
如果您已 TypeScript 安装，则输出将包含 TypeScript 版本号。如果 TypeScript 已安装，请直接跳至[步骤 1.4：安装 AWS CDK](#sample-cdk-install-cdk)。
1. 安装 TypeScript。为此，请运行带有**`install`**操作、**`-g`**选项和 TypeScript 软件包名称的**`npm`**命令。它 TypeScript 作为全局软件包安装在环境中。
```
npm install -g typescript
```
1. 确认 TypeScript 已安装。为此，请使用**`--version`**选项运行命令行 TypeScript 编译器。
```
tsc --version
```
如果 TypeScript 已安装，则输出将包含 TypeScript 版本号。
### 步骤 1.4：安装 AWS CDK
1. 确认您是否已经 AWS CDK 安装了。为此，请在终端会话仍在 IDE 中打开的情况下，运行带有** `--version` **选项的** `cdk` **命令。
```
cdk --version
```
如果安装了， AWS CDK 则输出将包含 AWS CDK 版本号和内部版本号。向前跳至 [步骤 2：添加代码](#sample-cdk-code)。
1. AWS CDK 通过运行**`npm`**命令以及`install`操作、要安装的 AWS CDK 软件包的名称以及在环境中全局安装软件包的`-g`选项来安装。
```
npm install -g aws-cdk
```
1. 确认已 AWS CDK 安装并正确引用。为此，请运行带 **`--version`** 选项的 **`cdk`** 命令。
```
cdk --version
```
如果成功，则会显示 AWS CDK 版本号和内部版本号。
## 步骤 2：添加代码
在此步骤中，您将创建一个示例 TypeScript 项目，其中包含 AWS CDK 以编程方式部署 AWS CloudFormation 堆栈所需的所有源代码。此堆栈在 AWS 您的账户中创建一个 Amazon SNS 主题和一个 Amazon SQS 队列，然后订阅该队列以订阅该主题。
1. 在终端会话仍在 IDE 中打开的情况下，创建存储项目源代码的目录，例如您环境中的 `~/environment/hello-cdk` 目录。然后切换到该目录。
```
rm -rf ~/environment/hello-cdk # Remove this directory if it already exists.
mkdir ~/environment/hello-cdk # Create the directory.
cd ~/environment/hello-cdk # Switch to the directory.
```
1. 将该目录设置为的 TypeScript 语言项目 AWS CDK。为此，请运行带有 ** `init` ** 操作、** `sample-app` ** 模板和 ** `--language` ** 选项以及编程语言名称的 ** `cdk` ** 命令。
```
cdk init sample-app --language typescript
```
这将在该目录中创建以下文件和子目录。
+ 隐藏的 `.git` 子目录和隐藏的 `.gitignore` 文件，可使项目与 Git 等源控制工具兼容。
+ `lib` 子目录，其中包含 `hello-cdk-stack.ts` 文件。此文件包含您的 AWS CDK 堆栈的代码。此代码将在此过程的下一步骤中介绍。
+ `bin` 子目录，其中包含 `hello-cdk.ts` 文件。此文件包含您的 AWS CDK 应用程序的入口点。
+ `node_modules` 子目录，其中包含应用程序和堆栈可根据需要使用的支持代码包。
+ 隐藏的 `.npmignore` 文件，其中列出了 **`npm`** 生成代码时不需要的子目录和文件类型。
+ `cdk.json` 文件，其中包含使 **`cdk`** 命令运行更轻松的信息。
+ `package-lock.json` 文件，其中包含 **`npm`** 可用于减少可能的生成和运行错误的信息。
+ `package.json` 文件，其中包含使 **`npm`** 命令运行更轻松以及可能减少构建和运行错误的信息。
+ 一个`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``StackProps``Queue`、和`Topic`类分别表示 CloudFormation 堆栈及其属性、可执行程序、Amazon SQS 队列和 Amazon SNS 主题。
+ 该`HelloCdkStack`类代表此应用程序的 CloudFormation 堆栈。此堆栈包含用于此应用程序的新 Amazon SQS 队列和 Amazon SNS 主题。
1. 在 **Environment（环境）**窗口中，打开 `bin/hello-cdk.ts` 文件，并浏览该文件中的以下代码。
```
#!/usr/bin/env node
import cdk = require('@aws-cdk/cdk');
import { HelloCdkStack } from '../lib/hello-cdk-stack';
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack');
app.run();
```
此代码从 `HelloCdkStack` 文件中加载、实例化然后运行 `lib/hello-cdk-stack.ts` 类。
1. 用于**`npm`**运行编 TypeScript 译器以检查编码错误，然后启用 AWS CDK 以执行项目的`bin/hello-cdk.js`文件。为此，请从项目的根目录中运行带有 ** `run` ** 操作的 ** `npm` ** 命令，指定 `package.json` 文件中的 ** `build` ** 命令值，如下所示。
```
npm run build
```
前面的命令运行 TypeScript 编译器，该编译器添加了支持`lib/hello-cdk-stack.d.ts`文件`bin/hello-cdk.d.ts`和文件。该编译器还可将 `hello-cdk.ts` 和 `hello-cdk-stack.ts` 文件转换为 `hello-cdk.js` 和 `hello-cdk-stack.js` 文件。
## 步骤 3：运行代码
在此步骤中，您将指示根据`bin/hello-cdk.js`文件中的代码创建 CloudFormation 堆栈模板。 AWS CDK 然后，您指示部署堆栈，该 AWS CDK 堆栈将创建 Amazon SNS 主题和 Amazon SQS 队列，然后为队列订阅该主题。然后，通过从主题向队列发送消息，确认已成功部署主题和队列。
1. AWS CDK 创建 CloudFormation 堆栈模板。为此，在终端会话仍在 IDE 中打开的情况下，从项目的根目录，运行带有 **`synth`** 操作和堆栈名称的 **`cdk`** 命令。
```
cdk synth HelloCdkStack
```
如果成功，输出将显示 CloudFormation 堆栈模板的`Resources`部分。
1. 首次在特定 AWS 账户和 AWS 区域组合的环境中部署 AWS CDK 应用程序时，必须安装*引导堆栈*。该堆栈包含完成各种操作 AWS CDK 所需的各种资源。例如，此堆栈包含一个 Amazon S3 存储桶， AWS CDK 用于在其部署过程中存储模板和资产。要安装引导堆栈，请运行带有** `bootstrap` **操作的** `cdk` **命令。
```
cdk bootstrap
```
**注意**
如果您在`cdk bootstrap`未指定任何选项的情况下运行，则使用默认 AWS 账户和 AWS 区域。您也可以通过指定配置文件和 account/Region 组合来引导特定环境。例如：
```
cdk bootstrap --profile test 123456789012/us-east-1
```
1. 让 AWS CDK 运行 CloudFormation 堆栈模板来部署堆栈。为此，从项目的根目录，运行带有 **`deploy`** 操作和堆栈名称的 **`cdk`** 命令。
```
cdk deploy HelloCdkStack
```
如果成功，则输出将显示 `HelloCdkStack` 堆栈已部署且没有错误。
**注意**
如果输出显示堆栈未定义环境、无法从标准位置获取 AWS 凭据或未配置区域的消息，请确保在 IDE 中正确设置了您的 AWS 凭据，然后再次运行该**`cdk deploy`**命令。有关更多信息，请参阅 [AWS 服务 从中的环境中呼叫 AWS Cloud9](credentials.md)。
1. 要确认 Amazon SNS 主题和 Amazon SQS 队列已成功部署，请发送消息到该主题，然后检查队列是否收到消息。为此，您可以使用诸如 AWS Command Line Interface (AWS CLI) 或之类的工具 AWS CloudShell。有关这些工具的更多信息，请参阅 [AWS CLI 还有 aws-shell 教程 AWS Cloud9](sample-aws-cli.md)。
例如，要在终端会话仍在 IDE 中处于打开状态的情况下 AWS CLI 向主题发送消息，请使用运行 Amazon SNS **`publish`**命令，提供消息的主题和正文、主题的 AWS 区域以及主题的 Amazon 资源名称 (ARN)。
```
aws sns publish --subject "Hello from the AWS CDK" --message "This is a message from the AWS CDK." --topic-arn arn:aws:sns:us-east-2:123456789012:HelloCdkStack-HelloCdkTopic1A234567-8BCD9EFGHIJ0K
```
在前面的命令中，`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 中打开的情况下，从项目的根目录，运行 **`cdk`** 命令及 **`destroy`** 操作和堆栈名称。
```
cdk destroy HelloCdkStack
```
当系统提示删除堆栈时，请键入 `y`，然后按 `Enter` 键。
如果成功，则输出将显示 `HelloCdkStack` 堆栈已删除且没有错误。
### 步骤 4.2：删除环境
要删除环境，请参阅 [删除中的环境 AWS Cloud9](delete-environment.md)。
# LAMP 教程适用于 AWS Cloud9
本教程允许您设置和运行 LAMP (Linux, Apache HTTP 服务器，MySQL，以及 PHP) 在 AWS Cloud9 开发环境中。
按照本教程并创建此示例可能会导致向您收取费用 AWS 账户。其中包括亚马逊弹性计算云 (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 的亚马逊 EC2 实例，或者 Ubuntu 服务器。如果您有不同类型的环境或操作系统，可能需要按照本示例的说明来设置相关的工具。有关更多信息，请参阅 [在中创建环境 AWS Cloud9](create-environment.md)。
+ **您已经打开了现有环境的 AWS Cloud9 IDE。**打开环境时，会在 Web 浏览器中 AWS Cloud9 打开该环境的 IDE。有关更多信息，请参阅 [在中打开环境 AWS Cloud9](open-environment.md)。
## 步骤 1：安装工具
在本步骤中，您将安装以下工具：
+ Apache HTTP 服务器，一个 Web 服务器主机。
+ PHP，一种脚本语言，特别适用于 Web 开发并可嵌入到 HTML 中。
+ MySQL，数据库管理系统。
然后，您可以通过开始完成此步骤 Apache HTTP 服务器然后 MySQL.
1. 确保已在实例上安装了最新的安全更新和错误修复。为此，在 AWS Cloud9 IDE 的终端会话中，运行 for (Amazon Linux) 或 f **`apt update`**or (**`yum update`**Ubuntu 服务器）命令。（要开始新的终端会话，请在菜单栏上依次选择 **Window（窗口）**> **New Terminal（新建终端）**。）
对于 Amazon Linux：
```
sudo yum -y update
```
对于 Ubuntu 服务器：
```
sudo apt -y update
```
1. 检查是否 Apache HTTP 服务器已经安装完毕。为此，请运行 **`httpd -v`**（适用于亚马逊 Linux）或 **`apache2 -v`**（对于 Ubuntu 服务器）命令。
如果成功，则输出包含 Apache HTTP 服务器版本号。
如果您看到错误，请安装 Apache 通过运行**`install`**命令获得 HTTP 服务器。
对于 Amazon Linux：
```
sudo yum install -y httpd24
```
对于 Ubuntu 服务器：
```
sudo apt install -y apache2
```
1. 确认是否 PHP 已通过运行**`php -v`**命令进行安装。
如果成功，输出将包含 PHP 版本号。
如果您看到错误，则通过运行 **`install`** 命令安装 PHP。
对于 Amazon Linux：
```
sudo yum install -y php56
```
对于 Ubuntu 服务器：
```
sudo apt install -y php libapache2-mod-php php-xml
```
1. 确认是否 MySQL 已通过运行**`mysql --version`**命令进行安装。
如果成功，则输出包含 MySQL 版本号。
如果您看到错误，请安装 MySQL 通过运行**`install`**命令。
对于 Amazon Linux：
```
sudo yum install -y mysql-server
```
对于 Ubuntu 服务器：
```
sudo apt install -y mysql-server
```
1. 在你安装之后 Apache HTTP 服务器，PHP，以及 MySQL，开始 Apache HTTP 服务器，然后通过运行以下命令确认它已启动。
对于 Amazon Linux（可能需要运行此命令两次）：
```
sudo service httpd start && sudo service httpd status
```
对于 Ubuntu 服务器（要返回命令提示符，请按`q`）：
```
sudo service apache2 start && sudo service apache2 status
```
1. 启动 MySQL，然后通过运行以下命令确认它已启动。
对于 Amazon Linux：
```
sudo service mysqld start && sudo service mysqld status
```
对于 Ubuntu 服务器（要返回命令提示符，请按`q`）：
```
sudo service mysql start && sudo service mysql status
```
## 第 2 步：设置 MySQL
在此步骤中，您进行设置 MySQL 要关注 MySQL 安全最佳实践。这些安全最佳实践包括为根账户设置密码和删除可从本地主机外部访问的根账户。其他需要注意的最佳实践是删除匿名用户的权限，删除测试数据库，以及删除允许任何人访问名称以 `test_` 开头的数据库的权限。
然后，你要通过练习开始然后退出来来来完成这一步 MySQL 命令行客户端。
1. 实施 MySQL 的安全最佳实践 MySQL 通过在 AWS Cloud9 IDE 的终端会话中运行以下命令进行安装。
```
sudo mysql_secure_installation
```
1. 在提示时，按照说明回答以下问题。
对于 Amazon Linux：
1. **输入当前的根密码（如无密码，按 Enter）** – 按 `Enter`（如无密码）。
1. **设置根密码** – 键入 `Y`，然后按 `Enter`。
1. **新建密码** – 键入密码，然后按 `Enter`。
1. **重新输入新密码** – 再次键入密码，然后按 `Enter`。（请务必将密码存储在安全位置以便以后使用。）
1. **删除匿名用户** – 键入 `Y`，然后按 `Enter`。
1. **禁止远程根登录** – 键入 `Y`，然后按 `Enter`。
1. **删除测试数据库以及对它的访问** – 键入 `Y`，然后按 `Enter`。
1. **立即重新加载权限表** – 键入 `Y`，然后按 `Enter`。
对于 Ubuntu 服务器：
1. **是否要设置“验证密码”插件** – 输入 `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 通过运行以下命令以 root 用户身份运行命令行客户端。在提示时，键入您之前设置的根用户的密码，然后按 `Enter`。当你进入`mysql>`时，提示会更改为 MySQL 命令行客户端。
```
sudo mysql -uroot -p
```
1. 要退出 MySQL 命令行客户端，运行以下命令。提示符变回 `$`。
```
exit;
```
## 步骤 3：设置网站
在此步骤中，您将设置默认网站根目录 Apache 具有推荐所有者和访问权限的 HTTP 服务器。然后你创建一个 PHP基于该默认网站根目录下的网页。
然后，您可以通过在亚马逊中设置安全组，在亚马逊 EC2 虚拟私有云（Amazon VPC）中设置与此 EC2 环境关联的网络访问控制列表（Amazon VPC），使传入的网络流量能够查看该网页。每个 EC2 环境都必须与 Amazon 中的安全组 EC2 和 Amazon VPC 中的网络 ACL 相关联。但是，即使 AWS 账户 中的原定设置网络 ACL 允许环境的所有传入和传出流量，原定设置安全组也仅允许端口 22 上使用 SSH 的传入流量。有关更多信息，请参阅 [AWS Cloud9 开发环境的 VPC 设置](vpc-settings.md)。
然后，在此步骤最后从 AWS Cloud9 IDE 外部成功查看网页。
1. 为设置默认网站根目录 Apache 具有推荐所有者和访问权限的 HTTP 服务器 (`/var/www/html`)。为此，请在 AWS Cloud9 IDE 的终端会话中按以下顺序逐一运行以下六个命令。要了解每个命令的作用，请阅读每个命令后面 `#` 字符后的信息。
对于 Amazon Linux：
```
sudo groupadd web-content # Create a group named web-content.
sudo usermod -G web-content -a ec2-user # Add the user ec2-user (your default user for this environment) to the group web-content.
sudo usermod -G web-content -a apache # Add the user apache (Apache HTTP Server) to the group web-content.
sudo chown -R ec2-user:web-content /var/www/html # Change the owner of /var/www/html and its files to user ec2-user and group web-content.
sudo find /var/www/html -type f -exec chmod u=rw,g=rx,o=rx {} \; # Change all file permissions within /var/www/html to user read/write, group read-only, and others read/execute.
sudo find /var/www/html -type d -exec chmod u=rwx,g=rx,o=rx {} \; # Change /var/www/html directory permissions to user read/write/execute, group read/execute, and others read/execute.
```
对于 Ubuntu 服务器：
```
sudo groupadd web-content # Create a group named web-content.
sudo usermod -G web-content -a ubuntu # Add the user ubuntu (your default user for this environment) to the group web-content.
sudo usermod -G web-content -a www-data # Add the user www-data (Apache HTTP Server) to the group web-content.
sudo chown -R ubuntu:web-content /var/www/html # Change the owner of /var/www/html and its files to user ubuntu and group web-content.
sudo find /var/www/html -type f -exec chmod u=rw,g=rx,o=rx {} \; # Change all file permissions within /var/www/html to user read/write, group read-only, and others read/execute.
sudo find /var/www/html -type d -exec chmod u=rwx,g=rx,o=rx {} \; # Change /var/www/html directory permissions to user read/write/execute, group read/execute, and others read/execute.
```
1. 创建一个 PHP基于的网页，`index.php`在默认的网站根文件夹中命名 Apache 通过运行以下命令获得 HTTP 服务器（即`/var/www/html`）。
对于 Amazon Linux：
```
sudo touch /var/www/html/index.php && sudo chown -R ec2-user:web-content /var/www/html/index.php && sudo chmod u=rw,g=rx,o=rx /var/www/html/index.php && sudo printf '%s\n%s\n%s' '' >> /var/www/html/index.php
```
前面的 Amazon Linux 命令还将文件的所有者更改为`web-content`，将文件组更改read/write for the user, and read/execute为，并将该组和其他人的文件权限更改为。`ec2-user`
对于 Ubuntu 服务器：
```
sudo touch /var/www/html/index.php && sudo chown -R ubuntu:web-content /var/www/html/index.php && sudo chmod u=rw,g=rx,o=rx /var/www/html/index.php && sudo printf '%s\n%s\n%s' '' >> /var/www/html/index.php
```
前面的命令为 Ubuntu 服务器还将文件的所有者更改为`ubuntu`，将文件组更改为`web-content`，并将该组和其他人的文件权限更改read/write for the user, and read/execute为。
如果成功，上述命令将使用以下内容创建 `index.php` 文件。
```
```
1. 通过在 Amazon VPC 中设置网络 ACL 和与此 EC2 环境关联的 Amazon 安全组，允许通过端口 80 EC2 的传入网络流量查看新网页。要执行此操作，按照以下顺序运行下面的八个命令，一次运行一个命令。要了解每个命令的作用，请阅读每个命令的 `#` 字符后的信息。
**重要**
运行以下命令可启用**所有** EC2 环境以及与此环境的安全组和网络 ACL 关联的 Amazon EC2 实例通过端口 80 传入的 Web 流量。这可能会导致该环境和 Amazon 实例以外的 EC2 环境和 Amazon EC2 实例意外启用通过端口 80 的传入网络流量。
**注意**
下面的第二到第四个命令启用安全组来允许端口 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 浏览器选项卡或与 AWS Cloud9 IDE 分开的其他 Web 浏览器转到显示的 URL。如果成功，网页将显示以下信息 Apache HTTP 服务器，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 开发环境。**本示例假设您已经有连接到运行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 实例的 EC2 环境。如果您有不同类型的环境或操作系统，可能需要按照本示例的说明来设置相关的工具。有关更多信息，请参阅 [在中创建环境 AWS Cloud9](create-environment.md)。
+ **您已经打开了现有环境的 AWS Cloud9 IDE。**打开环境时，会在 Web 浏览器中 AWS Cloud9 打开该环境的 IDE。有关更多信息，请参阅 [在中打开环境 AWS Cloud9](open-environment.md)。
+ **您有一个包含所有最新软件包 up-to-date的 EC2 实例**。在 AWS Cloud9 IDE 终端窗口中，您可以`-y`选择安装更新，而无需进行确认。`yum update`如果您希望在安装前检查更新，则可以忽略该选项。
```
sudo yum update -y
```
## 安装概览
WordPress 在您的环境的 EC2 实例上安装涉及以下步骤：
1. 安装和配置 MariaDB 服务器，这是一个用于存储安装信息的开源关系数据库 WordPress
1. 安装和配置 WordPress，包括编辑`wordpress.conf`配置文件
1. 配置托管网站的 Apache 服务器 WordPress
1. 预览由 Apache 服务器托管的 WordPress 网页内容
## 步骤 1：安装和配置 MariaDB Server
1. 在 AWS Cloud9 IDE 中，选择 “**窗口”、“****新建终端**”，然后输入以下命令来安装和启动 MariaDB 服务器安装：
```
sudo yum install -y mariadb-server
sudo systemctl start mariadb
```
1. 接下来，运行 `mysql_secure_installation` 脚本以提高 MariaDB Server 安装的安全性。
在提供对脚本的响应时，对第一个问题按 **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 Server
1. 在 AWS Cloud9 IDE 终端窗口中，确保已安装了 Apache：
```
httpd -v
```
如果 Apache 服务器并未安装，请运行以下命令：
```
sudo yum install -y httpd
```
1. 导航到 `/etc/httpd/conf.d` 目录，该目录是 Apache 虚拟主机配置文件的位置。然后使用 `ln` 命令将您之前创建的 `wordpress.conf` 链接到当前工作目录 (`/etc/httpd/conf.d`)：
```
cd /etc/httpd/conf.d
sudo ln -s /home/ec2-user/environment/config/wordpress.conf
```
1. 现在导航到 `/var/www` 目录，该目录是 Apache 服务器的默认根文件夹。然后使用 `ln` 命令将您之前创建的 `wordpress` 目录链接到当前工作目录 (`/var/www`)：
```
cd /var/www
sudo ln -s /home/ec2-user/environment/wordpress
```
1. 运行 `chmod` 命令以允许 Apache 服务器在 `wordpress` 子目录中运行内容：
```
sudo chmod +x /home/ec2-user/
```
1. 现在重启 Apache 服务器以允许其检测新的配置：
```
sudo service httpd restart
```
## 第 4 步：预览 WordPress 网页内容
1. 使用 AWS Cloud9 IDE 在以下目录`index.html`中创建一个名为的新文件：`environment/wordpress`。
1. 将 HTML 格式的文本添加到 `index.html`。例如：
```
Hello World!
```
1. 在**环境**窗口中，选择 `index.html` 文件，然后依次选择**预览**、**预览运行的应用程序**。
显示 *Hello World！（你好世界！）*消息的网页，会显示在应用程序预览选项卡中。要在首选浏览器中查看 Web 内容，请选择 **Pop Out Into a New Window（在新的弹出窗口中显示）**。
如果您删除`index.html`文件并刷新应用程序预览选项卡，则会显示 WordPress 配置页面。
## 管理混合内容错误
如果 WordPress 网站同时加载 HTTPS 和 HTTP 脚本或内容，Web 浏览器会显示该网站的混合内容错误。错误消息的措辞取决于您正在使用的 Web 浏览器，但会通知您与站点的连接不安全或不完全安全。您的 Web 浏览器会阻止访问混合内容。
**重要**
默认情况下，您在 AWS Cloud9 IDE 的应用程序预览选项卡中访问的所有网页都会自动使用 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 支持。这提供了对生产率特性的访问，比如代码完成、错误的 linting、特定于上下文的操作，以及调试选项，比如断点和步进。
有关更多信息，请参阅 [增强了对 Java 开发的支持](enhanced-java.md)。
本教程使你能够在 AWS Cloud9 开发环境中运行一些 Java 代码。
按照本教程操作并创建此示例可能会对您的 AWS 账户收费。其中包括可能对 Amazon EC2 和 Amazon S3 等服务收取的费用。有关更多信息，请参阅 [Amazon EC2 定价](https://aws.amazon.com/ec2/pricing/)和 [Amazon S3 定价](https://aws.amazon.com/s3/pricing/)。
**Topics**
+ [先决条件](#sample-java-prerequisites)
+ [步骤 1：安装所需工具](#sample-java-install)
+ [步骤 2：添加代码](#sample-java-code)
+ [步骤 3：生成并运行代码](#sample-java-run)
+ [第 4 步：设置为使用 适用于 Java 的 AWS SDK](#sample-java-sdk)
+ [步骤 5：在您的环境中设置 AWS 凭证管理](#sample-java-sdk-creds)
+ [第 6 步：添加 AWS SDK 代码](#sample-java-sdk-code)
+ [第 7 步：生成并运行 S AWS DK 代码](#sample-java-sdk-run)
+ [步骤 8：清除](#sample-java-clean-up)
## 先决条件
在使用此示例之前，请确保您的设置满足以下要求：
+ **您必须拥有现有 AWS Cloud9 的 EC2 开发环境。**本示例假设您已经有连接到运行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 实例的 EC2 环境。如果您有不同类型的环境或操作系统，可能需要按照本示例的说明来设置相关的工具。有关更多信息，请参阅 [在中创建环境 AWS Cloud9](create-environment.md)。
+ **您已经打开了现有环境的 AWS Cloud9 IDE。**打开环境时，会在 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。为此，在 AWS Cloud9 IDE 的终端会话中，使用**`-version`**选项运行 Java 运行器的命令行版本。（要开始新的终端会话，请在菜单栏上依次选择 **Window（窗口）**> **New Terminal（新建终端）**。）
```
java -version
```
根据上述命令的输出，执行以下操作之一：
+ 如果输出说明未找到 `java` 命令，请继续此过程中的步骤 2 来安装 OpenJDK 8。
+ 如果输出包含以 `Java(TM)`、`Java Runtime Environment`、`Java SE`、`J2SE` 或 `Java2` 开头的值，则表明未安装 OpenJDK 或未将 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。为此，请运行带 **`--config`** 选项的 **`update-alternatives`** 命令。运行此命令两次来切换或升级 Java 运行程序和编译器的命令行版本。
```
sudo update-alternatives --config java
sudo update-alternatives --config javac
```
在每个提示符处，键入 OpenJDK 8 的选择编号（包含 `java-1.8` 的那一个）。
1. 确认 Java 运行程序和编译器的命令行版本使用的是 OpenJDK 8。为此，请运行带 `-version` 选项的 Java 运行程序和编译器的命令行版本。
```
java -version
javac -version
```
如果已正确安装并设置 OpenJDK 8，则 Java 运行程序版本输出会包含以 `openjdk version 1.8` 开头的值，并且 Java 编译器版本输出会以值 `javac 1.8` 开头。
## 步骤 2：添加代码
在 AWS Cloud9 IDE 中，使用以下代码创建一个文件，然后使用名称保存该文件`hello.java`。（要创建文件，请在菜单栏上依次选择 **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` 文件。为此，请使用 AWS Cloud9 IDE 中的终端，从`hello.java`文件所在的同一目录中运行 Java 编译器，指定`hello.java`文件。
```
javac hello.java
```
1. 使用 Java 运行程序的命令行版本来运行 `hello.class` 文件。为此，请从 `hello.class` 文件所在的相同目录中，运行 Java 运行程序，指定在 `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
您可以增强此示例，使用创建 Amazon S3 存储桶，列出您的可用存储桶，然后删除您刚刚创建的存储桶。 适用于 Java 的 AWS SDK
在此步骤中，您将在环境中安装 [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 是否已安装，请使用 AWS Cloud9 IDE 中的终端运行 Maven 并带有该**`-version`**选项。
```
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 项目 Wiki 网站上的 [Extra Packages for Enterprise Linux (EPEL)](https://docs.fedoraproject.org/en-US/epel/)。
对于 Ubuntu Server，则运行以下命令。
```
sudo apt install -y maven
```
1. 带 **`-version`** 选项运行 Maven 以确认安装。
```
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 项目网站上的 [Maven Quickstart 原型](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`和设置的`dependency`部分`aws-java-sdk`包括 适用于 Java 的 AWS SDK 库文件。`artifactId`通过 `version` 设置声明要使用的 适用于 Java 的 AWS SDK 版本。要使用其他版本，请替换此版本号。
向前跳至 [步骤 5：在您的环境中设置 AWS 凭证管理](#sample-java-sdk-creds)。
### 使用 Gradle 设置
1. 在环境中安装 Gradle。要查看 Gradle 是否已安装，请使用 AWS Cloud9 IDE 中的终端运行 Gradle 并带有该**`-version`**选项。
```
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. 运行带 **`-version`** 选项的 Gradle 以确认安装。
```
gradle -version
```
1. 使用 Gradle 在环境中生成新的 Java 项目。为此，请使用终端运行以下命令来为项目创建目录，然后切换到该目录。
```
mkdir my-app
cd my-app
```
1. 运行以下命令来让 Gradle 在环境中的 `my-app` 目录中生成新的 Java 应用程序项目。
```
gradle init --type java-application
```
上述命令在环境中为项目创建以下目录结构。
```
my-app
|- .gradle
| `- (various supporting project folders and files)
|- gradle
| `- (various supporting project folders and files)
|- src
| |- main
| | `- java
| | `- App.java
| `- test
| `- java
| `- AppTest.java
|- build.gradle
|- gradlew
|- gradlew.bat
`- settings.gradle
```
1. 修改项目的 `AppTest.java`。（如果不这样做，则项目可能不会按预期方式构建或运行。） 为此，请从 **Environment（环境）**窗口中打开 `my-app/src/test/java/AppTest.java` 文件。在编辑器中，将该文件的当前内容替换为以下代码，然后保存 `AppTest.java` 文件。
```
import org.junit.Test;
import static org.junit.Assert.*;
public class AppTest {
@Test public void testAppExists () {
try {
Class.forName("com.mycompany.app.App");
} catch (ClassNotFoundException e) {
fail("Should have a class named App.");
}
}
}
```
1. 修改项目的 `build.gradle` 文件。（`build.gradle` 文件定义 Gradle 项目的设置。） 为此，请从 **Environment（环境）**窗口中打开 `my-app/build.gradle` 文件。在编辑器中，将该文件的当前内容替换为以下代码，然后保存 `build.gradle` 文件。
```
apply plugin: 'java'
apply plugin: 'application'
repositories {
jcenter()
mavenCentral()
}
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath "io.spring.gradle:dependency-management-plugin:1.0.3.RELEASE"
}
}
apply plugin: "io.spring.dependency-management"
dependencyManagement {
imports {
mavenBom 'com.amazonaws:aws-java-sdk-bom:1.11.330'
}
}
dependencies {
compile 'com.amazonaws:aws-java-sdk-s3'
testCompile group: 'junit', name: 'junit', version: '4.12'
}
run {
if (project.hasProperty("appArgs")) {
args Eval.me(appArgs)
}
}
mainClassName = 'App'
```
上述 `build.gradle` 文件包含指定声明的项目设置，如下所示：
+ 该`io.spring.dependency-management`插件用于导入 适用于 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 步：生成并运行 S AWS DK 代码
要运行上一步中的代码，请从终端中运行以下命令。这些命令使用 Maven 或 Gradle 为项目创建可执行的 JAR 文件，然后使用 Java 运行程序来运行 JAR。JAR 运行时使用要在 Amazon S3 中创建的存储桶的名称（例如`my-test-bucket`）和要在其中创建存储桶的 AWS 区域 ID 作为输入（例如`us-east-2`）。
对于 Maven，运行以下命令。
```
cd my-app
mvn package
java -cp target/my-app-1.0-SNAPSHOT-jar-with-dependencies.jar com.mycompany.app.App my-test-bucket us-east-2
```
对于 Gradle，运行以下命令。
```
gradle build
gradle run -PappArgs="['my-test-bucket', 'us-east-2']"
```
将结果与以下输出进行比较。
```
My buckets now are:
Creating a new bucket named 'my-test-bucket'...
My buckets now are:
my-test-bucket
Deleting the bucket named 'my-test-bucket'...
My buckets now are:
```
## 步骤 8：清除
为了防止在您使用完此示例后继续向您的 AWS 账户收费，您应该删除该环境。有关说明，请参阅[删除中的环境 AWS Cloud9](delete-environment.md)。
# 的 C\$1\$1 教程 AWS Cloud9
本教程使你能够在 AWS Cloud9 开发环境中运行 C\$1\$1 代码。该代码还使用 [适用于 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：获取并构建 SDK for C\$1\$1](#install-cmake)
+ [步骤 4：创建 C\$1\$1 和 CMake列表文件](#sample-cplusplus-sdk-code)
+ [步骤 5：构建并运行 C\$1\$1 代码](#build-and-run-cpp)
+ [步骤 6：清除](#sample-cplusplus-clean-up)
## 先决条件
在使用此示例之前，请确保您的设置满足以下要求：
+ **您必须拥有现有 AWS Cloud9 的 EC2 开发环境。**本示例假设您已经有连接到运行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 实例的 EC2 环境。如果您有不同类型的环境或操作系统，可能需要按照本示例的说明来设置相关的工具。有关更多信息，请参阅 [在中创建环境 AWS Cloud9](create-environment.md)。
+ **您已经打开了现有环境的 AWS Cloud9 IDE。**打开环境时，会在 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. 接下来，通过运行以下命令来运行引导程序脚本并安装 `cmake`：
```
./bootstrap
make
sudo make install
```
1. 通过运行以下命令以确认您已安装该工具：
```
cmake --version
```
## 步骤 3：获取并构建 SDK for C\$1\$1
要为 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` 来克隆开发工具源代码，以及使用 `cmake` 构建 SDK for C\$1\$1。
1. 在终端中运行以下命令，为您的 AWS Cloud9 环境克隆远程存储库并递归地获取所有 git 子模块：
```
git clone --recurse-submodules https://github.com/aws/aws-sdk-cpp
```
1. 导航到新`aws-sdk-cpp`目录，创建一个用于构建 C\$1\$1 AWS SDK 的子目录，然后导航到该目录：
```
cd aws-sdk-cpp
mkdir sdk_build
cd sdk_build
```
1.
**注意**
为节省时间，该步骤仅构建 适用于 C\$1\$1 的 AWS SDK的 Amazon S3 部分。如果要构建完整的开发工具包，请省略 `cmake` 命令中的 `-DBUILD_ONLY=s3`。
构建完整的 SDK for C\$1\$1 可能需要一小时以上才能完成，具体取决于 Amazon EC2 实例或您自己的服务器上的可用计算资源。
运行以下命令，使用 `cmake` 将 SDK for C\$1\$1 的 Amazon S3 部分构建到 `sdk_build` 目录下：
```
cmake .. -DBUILD_ONLY=s3
```
1. 现在，运行 `make install` 命令，以便可以访问构建的开发工具包：
```
sudo make install
cd ..
```
## 步骤 4：创建 C\$1\$1 和 CMake列表文件
在本步骤中，您将创建 `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 步：运行 S AWS DK 代码](#sample-python-sdk-run)
+ [步骤 7：清除](#sample-python-clean-up)
## 先决条件
使用本教程之前，确保满足以下要求。
+ **您有一个 AWS Cloud9 EC2 开发环境**
本教程假设您已有 EC2 环境，并且该环境已连接到运行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 实例。有关详细信息，请参阅 [创建 EC2 环境](create-environment-main.md)。
如果您有不同类型的环境或操作系统，您可能需要调整本教程的说明。
+ **您已经为该环境打开了 AWS Cloud9 IDE**
打开环境时，会在 Web 浏览器中 AWS Cloud9 打开该环境的 IDE。有关详细信息，请参阅 [在中打开环境 AWS Cloud9](open-environment.md)。
## 步骤 1：安装 Python
1. 在 AWS Cloud9 IDE 的终端会话中，通过运行**`python --version`**命令来确认 Python 是否已安装。（要开始新的终端会话，请在菜单栏上依次选择 **Window (窗口)**、**New Terminal (新建终端)**。） 如果已安装 Python，请向前跳至[步骤 2：添加代码](#sample-python-code)。
1. 运行 **`yum update`**（适用于 Amazon Linux）或 **`apt update`**（适用于 Ubuntu Server）命令，以帮助确保已安装最新的安全更新和错误修复。
对于 Amazon Linux：
```
sudo yum -y update
```
对于 Ubuntu Server：
```
sudo apt update
```
1. 通过运行 **`install`** 命令来安装 Python。
对于 Amazon Linux：
```
sudo yum -y install python3
```
对于 Ubuntu Server：
```
sudo apt-get install python3
```
## 步骤 2：添加代码
在 AWS Cloud9 IDE 中，创建一个包含以下内容的文件，并使用该名称保存该文件`hello.py`。（要创建文件，请在菜单栏上依次选择 **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 服务进行交互。例如，您可以使用开发工具包创建 Amazon S3 存储桶，列出您的可用存储桶，然后删除刚刚创建的存储桶。
### 安装 pip
在 AWS Cloud9 IDE 中，通过运行命令来确认`pip`是否已经为活动版本的 Python 安装了该**`python -m pip --version`**命令。如果已安装 `pip`，请跳到下一节。
要安装 `pip`，请运行以下命令。由于 sudo 与用户处于不同的环境中，因此，如果 Python 的版本与当前别名版本不同，则必须指定要使用的 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 服务时，都必须为呼叫提供一组凭据。这些凭证确定开发工具包是否具有必需的权限以进行调用。如果凭证没有包括必需的权限，调用将失败。
要在环境中存储凭证，请按照 [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 步：运行 S AWS DK 代码
1. 在菜单栏上依次选择**运行**、**运行配置**和**新建运行配置**。
1. 在 **Comman** d 中`s3.py my-test-bucket us-west-2`，输入，其中`my-test-bucket``us-west-2`是要创建的存储桶的名称，也是创建存储桶所在 AWS 区域的 ID。默认情况下，您的存储桶会在脚本退出之前被删除。要保留您的存储桶，请将 `--keep_bucket` 添加到您的命令中。有关 AWS 区域列表 IDs，请参阅中的 [Amazon 简单存储服务终端节点和配额*AWS 一般参考*](https://docs.aws.amazon.com/general/latest/gr/s3.html)。
**注意**
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 步：生成并运行 S AWS DK 代码](#sample-dotnetcore-sdk-run)
+ [步骤 9：清除](#sample-dotnetcore-clean-up)
## 先决条件
在使用此示例之前，请确保您的设置满足以下要求：
+ **您必须拥有现有 AWS Cloud9 的 EC2 开发环境。**本示例假设您已经有连接到运行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 实例的 EC2 环境。如果您有不同类型的环境或操作系统，可能需要按照本示例的说明来设置相关的工具。有关更多信息，请参阅 [在中创建环境 AWS Cloud9](create-environment.md)。
+ **您已经打开了现有环境的 AWS Cloud9 IDE。**打开环境时，会在 Web 浏览器中 AWS Cloud9 打开该环境的 IDE。有关更多信息，请参阅 [在中打开环境 AWS Cloud9](open-environment.md)。
## 步骤 1：安装所需工具
在此步骤中，将运行此示例需要的 .NET 开发工具包安装到环境中。
1. 确认环境中是否已安装 .NET 开发工具包的最新版本。为此，请在 AWS Cloud9 IDE 的终端会话中运行带有**`--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，在 AWS Cloud9 IDE 的终端会话中，运行以下命令以帮助确保安装了最新的安全更新和错误修复，并安装.NET SDK 所需的`libunwind`软件包。（要开始新的终端会话，请在菜单栏上依次选择 **Window (窗口)、New Terminal (新建终端)**。）
```
sudo yum -y update
sudo yum -y install libunwind
```
对于 Ubuntu Server，在 AWS Cloud9 IDE 的终端会话中，运行以下命令以帮助确保安装了最新的安全更新和错误修复。（要开始新的终端会话，请在菜单栏上依次选择 **Window (窗口)、New Terminal (新建终端)**。）
```
sudo apt -y update
```
1. 通过运行以下命令，将 .NET 开发工具包安装程序脚本下载到环境中。
```
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 开发工具包。
```
. ~/.bashrc
```
1. 通过运行带 **`--help`** 选项的 .NET CLI 确认已加载 .NET 开发工具包。
```
dotnet --help
```
如果成功，则显示 .NET 开发工具包版本号，以及附加的使用信息。
1. 如果不想再在环境中保留 .NET 开发工具包安装程序脚本，则可按如下所述将其删除。
```
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：添加代码
在此步骤中，您将向应用程序中添加一些代码。
在 AWS Cloud9 IDE 的 “**环境**” 窗口中，打开该`hello/Program.cs`文件。
在编辑器中，将该文件的当前内容替换为以下代码，然后保存 `Program.cs` 文件。
```
using System;
namespace hello
{
class Program
{
static void Main(string[] args)
{
if (args.Length < 2) {
Console.WriteLine("Please provide 2 numbers");
return;
}
Console.WriteLine("Hello, World!");
Console.WriteLine("The sum of 2 and 3 is 5.");
int sum = Int32.Parse(args[0]) + Int32.Parse(args[1]);
Console.WriteLine("The sum of {0} and {1} is {2}.",
args[0], args[1], sum);
}
}
}
```
## 步骤 5：生成并运行代码
在此步骤中，您会将该项目及其依赖项生成为一组二进制文件，包括一个可运行的应用程序文件。然后运行该应用程序。
1. 在 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 (生成)**。
此生成器将向 `hello/obj` 子目录中添加一个名为 `bin` 的子目录和一个名为 `Debug` 的子目录。请注意以下三个关键文件。
+ `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 开发工具包的版本。根据您安装的版本，您可能会在文件夹名称中看到不同的编号。
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.dll` 目录中的 `hello/bin/Debug/netcoreapp3.1` 文件。
将输出与以下内容进行比较。
```
Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.
```
## 步骤 6：创建和设置使用.NET 控制台应用程序项目 适用于 .NET 的 AWS SDK
您可以增强此示例，使用创建 Amazon S3 存储桶，列出您的可用存储桶，然后删除您刚刚创建的存储桶。 适用于 .NET 的 AWS SDK
在此新项目中，您将添加对 适用于 .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，并在中指定 Amazon S3 软件包的名称 NuGet。 （NuGet定义如何创建、托管和使用.NET 软件包，并为每个角色提供工具。）
```
dotnet add package AWSSDK.S3
```
向 Amazon S3 包添加项目引用时， NuGet 还会向其余部分添加项目引用 适用于 .NET 的 AWS SDK。
**注意**
有关中其他 AWS 相关软件包的名称和版本 NuGet，请参阅网站上[标有 aws-sdk 的NuGet NuGet 软件包](https://www.nuget.org/packages?q=Tags%3A%22aws-sdk%22)。
### 设置 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 交互的代码，以用于创建存储桶、删除刚刚创建的存储桶，然后列出可用的存储桶。
在 AWS Cloud9 IDE 的 “**环境**” 窗口中，打开该`s3/Program.cs`文件。在编辑器中，将该文件的当前内容替换为以下代码，然后保存 `Program.cs` 文件。
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using Amazon.S3.Util;
using System;
using System.Threading.Tasks;
namespace s3
{
class Program
{
async static Task Main(string[] args)
{
if (args.Length < 2) {
Console.WriteLine("Usage: ");
Console.WriteLine("Example: my-test-bucket us-east-2");
return;
}
if (args[1] != "us-east-2") {
Console.WriteLine("Cannot continue. The only supported AWS Region ID is " +
"'us-east-2'.");
return;
}
var bucketRegion = RegionEndpoint.USEast2;
// Note: You could add more valid AWS Regions above as needed.
using (var s3Client = new AmazonS3Client(bucketRegion)) {
var bucketName = args[0];
// Create the bucket.
try
{
if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
{
Console.WriteLine("Cannot continue. Cannot create bucket. \n" +
"A bucket named '{0}' already exists.", bucketName);
return;
} else {
Console.WriteLine("\nCreating the bucket named '{0}'...", bucketName);
await s3Client.PutBucketAsync(bucketName);
}
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Cannot continue. {0}", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Cannot continue. {0}", e.Message);
}
// Confirm that the bucket was created.
if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
{
Console.WriteLine("Created the bucket named '{0}'.", bucketName);
} else {
Console.WriteLine("Did not create the bucket named '{0}'.", bucketName);
}
// Delete the bucket.
Console.WriteLine("\nDeleting the bucket named '{0}'...", bucketName);
await s3Client.DeleteBucketAsync(bucketName);
// Confirm that the bucket was deleted.
if (await AmazonS3Util.DoesS3BucketExistV2Async(s3Client, bucketName))
{
Console.WriteLine("Did not delete the bucket named '{0}'.", bucketName);
} else {
Console.WriteLine("Deleted the bucket named '{0}'.", bucketName);
};
// List current buckets.
Console.WriteLine("\nMy buckets now are:");
var response = await s3Client.ListBucketsAsync();
foreach (var bucket in response.Buckets)
{
Console.WriteLine(bucket.BucketName);
}
}
}
}
}
```
## 第 8 步：生成并运行 S AWS DK 代码
在此步骤中，您会将该项目及其依赖项生成为一组二进制文件，包括一个可运行的应用程序文件。然后运行该应用程序。
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.dll` 目录中的 `s3/bin/Debug/netcoreapp3.1` 文件。
将结果与以下输出进行比较。
```
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 账户被扣款。其中包括亚马逊 EC2 和Amazon S3等服务可能产生的费用。有关更多信息，请参阅 [Amazon EC2 定价](https://aws.amazon.com/ec2/pricing/)和 A [mazon 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 开发工具包](#sample-nodejs-sdk)
+ [第 5 步：添加 AWS SDK 代码](#sample-nodejs-sdk-code)
+ [第 6 步：运行 S AWS DK 代码](#sample-nodejs-sdk-run)
+ [步骤 7：清除](#sample-nodejs-clean-up)
## 先决条件
在使用此示例之前，请确保您的设置满足以下要求：
+ **您必须拥有现有的 AWS Cloud9 EC2 开发环境。**此示例假设您的 EC2 环境已连接到运行 Amazon Linux 的亚马逊 EC2 实例，或者 Ubuntu 服务器。如果您有不同类型的环境或操作系统，可能需要按照本示例的说明来设置相关的工具。有关更多信息，请参阅 [在中创建环境 AWS Cloud9](create-environment.md)。
+ **您已经打开了现有环境的 AWS Cloud9 IDE。**打开环境时，会在 Web 浏览器中 AWS Cloud9 打开该环境的 IDE。有关更多信息，请参阅 [在中打开环境 AWS Cloud9](open-environment.md)。
## 步骤 1：安装所需工具
在该步骤中，您安装运行本示例所需的 Node.js。
1. 在 AWS Cloud9 IDE 的终端会话中，通过运行**`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，首先运行此命令下载节点版本管理器 (nvm)。 （nvm 是一个简单的 Bash shell 脚本，可用于安装和管理 Node.js 版本。 有关更多信息，请参阅 GitHub 网站上的[节点版本管理器](https://github.com/creationix/nvm/blob/master/README.md)。）
```
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.5/install.sh | bash
```
1. 要开始使用 nvm，请关闭终端会话并重新启动，或者查找包含命令以加载 nvm 的 `~/.bashrc` 文件。
```
. ~/.bashrc
```
1. 运行此命令在 Amazon Linux 2、Amazon Linux 1 和 Ubuntu 18.04 上安装 Node.js 16。Amazon Linux 1 和 Ubuntu 18.04 实例最高仅支持 Node.js 版本 16。
```
nvm install 16
```
运行此命令在 Amazon Linux 2023 和 Ubuntu 22.04 上安装最新版本的 Node.js：
```
nvm install --lts && nvm alias default lts/*
```
**注意**
最新的 AL2 023 AWS Cloud9 镜像安装了 Node.js 20，最新的亚马逊 Linux 2 AWS Cloud9 镜像安装了 Node.js 18。如果你想在 Amazon Linux 2 上 AWS Cloud9 手动安装 Node.js 18，请在 AWS Cloud9 IDE 终端中运行以下命令：
```
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.
```
![\[在 AWS Cloud9 IDE 中运行代码后的 Node.js 输出\]](http://docs.aws.amazon.com/zh_cn/cloud9/latest/user-guide/images/ide-nodejs-simple.png)
## 第 4 步：在 Node.js JavaScript 中安装和配置 AWS 开发工具包
在中运行 Node.js 脚本时 AWS Cloud9，可以在版本 3 (V3) 的 AWS SDK 和 JavaScript 版本 2 (V2) 的旧 JavaScript 版 AWS SDK 之间进行选择。与 V2 一样，V3 使您可以轻松地使用 Amazon Web Services，但它已经写入 TypeScript并添加了几项经常要求的功能，例如模块化软件包。
------
#### [ AWS SDK for JavaScript (V3) ]
您可以增强此示例，使用 Node.js JavaScript 中的 AWS 软件开发工具包创建 Amazon S3 存储桶，列出您的可用存储桶，然后删除您刚刚创建的存储桶。
在此步骤中，您将在 Node.js 中安装和配置 AWS 软件开发工具包的 Amazon S3 服务客户端模块，该模块提供了一种通过 JavaScript 代码与 Amazon S3 AWS 服务进行交互的便捷方式。 JavaScript
如果要使用其他 AWS 服务，则需要单独安装它们。有关安装 AWS 模块的更多信息，请参阅[*AWS 开发人员指南 (V3)*。](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/working-with-services)有关如何开始使用 Node.js 和 AWS 适用于 JavaScript (V3) 的 SDK 的信息，请参阅《* JavaScript开发者开发AWS 工具包指南》(V3)* 中的 [Node.js 入](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/getting-started-nodejs.html#getting-started-nodejs-setup-structure)门。
JavaScript 在 Node.js 中安装 AWS 适用的 SDK 后，您必须在自己的环境中设置凭据管理。Node.js JavaScript 中的 S AWS DK 需要这些凭据才能与 AWS 服务进行交互。
**在 Node.js JavaScript 中安装 AWS 适用的 SDK**
可以使用 npm 运行 **`install`** 命令。
```
npm install @aws-sdk/client-s3
```
有关更多信息，请参阅[《适用于 JavaScript 的 AWS SDK 开发人员指南》 JavaScript中的安装软件](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 中的 S AWS DK 是否具有进行该调用的相应权限。如果这些凭证不包含相应的权限，调用将失败。
在此步骤中，您将凭证存储在环境内。为此，请按照 [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 软件开发工具包创建 Amazon S3 存储桶，列出您的可用存储桶，然后删除您刚刚创建的存储桶。
在此步骤中，您将在 Node.js JavaScript 中安装和配置 AWS 软件开发工具包，它提供了一种通过 JavaScript代码与 Amazon S3 等 AWS 服务进行交互的便捷方式。 JavaScript 在 Node.js 中安装 AWS 适用的 SDK 后，您必须在自己的环境中设置凭据管理。Node.js JavaScript 中的 S AWS DK 需要这些凭据才能与 AWS 服务进行交互。
**在 Node.js JavaScript 中安装 AWS 适用的 SDK**
可以使用 npm 运行 **`install`** 命令。
```
npm install aws-sdk
```
有关更多信息，请参阅[《适用于 JavaScript 的 AWS SDK 开发人员指南》 JavaScript中的安装软件](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/installing-jssdk.html)*开发*工具包。
**在环境中设置凭证管理**
每次使用 Node.js JavaScript 中的 AWS SDK 调用 AWS 服务时，都必须在调用时提供一组凭据。这些凭证决定了 Node.js JavaScript 中的 S AWS DK 是否具有进行该调用的相应权限。如果这些凭证不包含相应的权限，调用将失败。
在此步骤中，您将凭证存储在环境内。为此，请按照 [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 步：运行 S AWS DK 代码
1. 使用 npm 运行 **`install`** 命令，以允许代码异步调用 Amazon S3 操作。
```
npm install async
```
1. 在 AWS Cloud9 IDE 的菜单栏上，选择 “运行”、“**运行****配置**”、“**新建运行配置**”。
1. 在 **[New] - Idle ([新建] - 空闲)** 选项卡上，选择 **Runner: Auto (运行程序: 自动)**，然后选择 **Node.js**。
1. 如果您使用的是 JavaScript (V3) 的 AWS SDK，则使用**命令**类型`s3.js`。如果您使用的是适用于 Javascript 的 AWS SDK (v2)`s3.js my-test-bucket us-east-2`，则对于**命令**类型，其中`my-test-bucket`是您要创建然后删除的存储桶的名称，`us-east-2`也是您要在其中创建存储桶的 AWS 区域的 ID。欲了解更多信息 IDs，请参阅中的[亚马逊简单存储服务 (Amazon S3) S](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) ervice。*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 步：运行 S AWS DK 代码](#sample-php-sdk-run)
+ [步骤 7：清除](#sample-php-clean-up)
## 先决条件
在使用此示例之前，请确保您的设置满足以下要求：
+ **您必须拥有现有 AWS Cloud9 的 EC2 开发环境。**本示例假设您已经有连接到运行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 实例的 EC2 环境。如果您有不同类型的环境或操作系统，可能需要按照本示例的说明来设置相关的工具。有关更多信息，请参阅 [在中创建环境 AWS Cloud9](create-environment.md)。
+ **您已经打开了现有环境的 AWS Cloud9 IDE。**打开环境时，会在 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)。
1. 在 AWS Cloud9 IDE 的终端会话中，通过运行**`php --version`**命令来确认 PHP 是否已安装。（要开始新的终端会话，请在菜单栏上依次选择 **Window（窗口）**> **New Terminal（新建终端）**。） 如果成功，输出将包含 PHP 版本号。如果已安装 PHP，请向前跳至 [步骤 2：添加代码](#sample-php-code)。
1. 运行 **`yum update`**（适用于 Amazon Linux）或 **`apt update`**（适用于 Ubuntu Server）命令，以帮助确保已安装最新的安全更新和错误修复。
对于 Amazon Linux 2 和 Amazon Linux：
```
sudo yum -y update
```
对于 Ubuntu Server：
```
sudo apt update
```
1. 通过运行** `install` **命令安装 PHP。
对于 Amazon Linux 2：
```
sudo amazon-linux-extras install -y php7.2
```
对于 Amazon Linux：
```
sudo yum -y install php72
```
**注意**
您可以使用以下命令查看 Amazon Linux 的版本：
```
cat /etc/system-release
```
对于 Ubuntu Server：
```
sudo apt install -y php php-xml
```
有关更多信息，请参阅 PHP 网站上的[安装和配置](http://php.net/manual/en/install.php)。
## 步骤 2：添加代码
在 AWS Cloud9 IDE 中，使用此内容创建一个文件，然后使用该名称保存该文件`hello.php`。（要创建文件，请在菜单栏上依次选择 **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.
```
![\[在 AWS Cloud9 IDE 中运行 PHP 代码的输出\]](http://docs.aws.amazon.com/zh_cn/cloud9/latest/user-guide/images/ide-php-simple.png)
## 步骤 4：安装和配置 适用于 PHP 的 AWS SDK
您可以增强此示例，使用创建 Amazon S3 存储桶，列出您的可用存储桶，然后删除您刚刚创建的存储桶。 适用于 PHP 的 AWS SDK
在此步骤中，您将安装和配置 适用于 PHP 的 AWS SDK，它提供了一种通过您的 PHP 代码与 Amazon S3 等 AWS 服务进行交互的便捷方式。在安装之前 适用于 PHP 的 AWS SDK，您应该先安装 C [omposer](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 步：运行 S AWS DK 代码
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。有关更多信息 IDs，请参阅 PHP 网站上的[支持时区列表](http://php.net/manual/en/timezones.php)。
+ `my-test-bucket` 是您要创建，然后删除的存储桶的名称。
**注意**
Amazon S3 存储桶名称必须是唯一的，而 AWS不仅仅是您的 AWS 账户。
+ `us-east-2`是您要在其中创建存储桶的 AWS 区域的 ID。欲了解更多信息 IDs，请参阅中的[亚马逊简单存储服务 (Amazon S3) S](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) ervice。*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 *开发者指南》中的 “ AWS Cloud9 与AWS 适用于 Ruby 的开发*工具包一起使用](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/cloud9-ruby.html)”。
**注意**
遵循本教程可能会导致您的 AWS 账户被扣款。其中包括亚马逊 EC2 和Amazon S3等服务可能产生的费用。有关更多信息，请参阅 [Amazon EC2 定价](https://aws.amazon.com/ec2/pricing/)和 A [mazon S3 定价](https://aws.amazon.com/s3/pricing/)。
# 去教程 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 步：运行 S AWS DK 代码](#sample-go-sdk-run)
+ [步骤 7：清除](#sample-go-clean-up)
## 先决条件
在使用此示例之前，请确保您的设置满足以下要求：
+ **您必须拥有现有 AWS Cloud9 的 EC2 开发环境。**本示例假设您已经有连接到运行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 实例的 EC2 环境。如果您有不同类型的环境或操作系统，可能需要按照本示例的说明来设置相关的工具。有关更多信息，请参阅 [在中创建环境 AWS Cloud9](create-environment.md)。
+ **您已经打开了现有环境的 AWS Cloud9 IDE。**打开环境时，会在 Web 浏览器中 AWS Cloud9 打开该环境的 IDE。有关更多信息，请参阅 [在中打开环境 AWS Cloud9](open-environment.md)。
## 步骤 1：安装所需工具
在此步骤中，安装和配置运行此示例需要的 Go。
1. 在 AWS Cloud9 IDE 的终端会话中，通过运行**`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 (我的 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]`。
![\[在 AWS Cloud9 IDE 中运行 Go 代码的输出\]](http://docs.aws.amazon.com/zh_cn/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
您可以增强此示例，使用创建 Amazon S3 存储桶，列出您的可用存储桶，然后删除您刚刚创建的存储桶。 适用于 Go 的 AWS SDK
在此步骤中，您将安装和配置 适用于 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 步：运行 S AWS DK 代码
1. 在 AWS Cloud9 IDE 的菜单栏上，选择 “运行”、“**运行****配置**”、“**新建运行配置**”。
1. 在 **[New] - Idle ([新建] - 空闲)** 选项卡上，选择 **Runner: Auto (运行程序: 自动)**，然后选择 **Go**。
1. 在 **Comman** d 中`s3.go YOUR_BUCKET_NAME THE_AWS_REGION `，键入，其中` YOUR_BUCKET_NAME `是您要创建然后删除的存储桶的名称，` THE_AWS_REGION `也是您要在其中创建存储桶的 AWS 区域的 ID。例如，对于美国东部 (俄亥俄) 区域，请使用 `us-east-2`。欲了解更多信息 IDs，请参阅中的[亚马逊简单存储服务 (Amazon S3) S](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) ervice。*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 开发工具包](#sample-typescript-sdk)
+ [第 5 步：添加 AWS SDK 代码](#sample-typescript-sdk-code)
+ [第 6 步：运行 S AWS DK 代码](#sample-typescript-sdk-run)
+ [步骤 7：清除](#sample-typescript-clean-up)
## 先决条件
在使用此示例之前，请确保您的设置满足以下要求：
+ **您必须拥有现有 AWS Cloud9 的 EC2 开发环境。**本示例假设您已经有连接到运行 Amazon Linux 或 Ubuntu Server 的 Amazon EC2 实例的 EC2 环境。如果您有不同类型的环境或操作系统，可能需要按照本示例的说明来设置相关的工具。有关更多信息，请参阅 [在中创建环境 AWS Cloud9](create-environment.md)。
+ **您已经打开了现有环境的 AWS Cloud9 IDE。**打开环境时，会在 Web 浏览器中 AWS Cloud9 打开该环境的 IDE。有关更多信息，请参阅 [在中打开环境 AWS Cloud9](open-environment.md)。
## 步骤 1：安装所需工具
在此步骤中，您将使用 Node P TypeScript ackage Manager (**`npm`**) 进行安装。要安装 **`npm`**，请使用节点版本管理器 (**`nvm`**)。如果您没有 **`nvm`**，则在此步骤中首先安装它。
1. 在 AWS Cloud9 IDE 的终端会话中，通过运行带**`--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`**，请先运行以下命令下载节点版本管理器 (**`nvm`**)。 (**`nvm`**是一个简单的 Bash shell 脚本，可用于安装和管理 Node.js 版本。 有关更多信息，请参阅 GitHub 网站上的[节点版本管理器](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. 运行 **`nvm`** 以安装最新版本的 Node.js 16。（**`npm`** 包含在 Node.js 中。）
```
nvm install v16
```
1. 带 **`--version`** 选项运行命令行版本的 Node.js 以确认已安装 Node.js。
```
node --version
```
1. 运行带 ** `--version` ** 选项的 ** `npm` ** 以确认已安装 ** `npm` **。
```
npm --version
```
1. TypeScript 通过**`npm`**使用**`-g`**选项运行来安装。它 TypeScript 作为全局软件包安装在环境中。
```
npm install -g typescript
```
1. 通过运行带有**`--version`**选项的命令行 TypeScript编译器来确认已安装。 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` 文件夹。这个新文件夹包含 Node.js 类型定义，在本操作步骤的稍后部分 TypeScript 需要这些定义才能用于将要添加到`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) 库文件将文件中的 TypeScript 代码转换为名`hello.js`为`hello.ts`的文件中的等效 JavaScript 代码。
1. 在 **Environment (环境)** 窗口中，打开 `hello.js` 文件。
1. 在菜单栏上依次选择**运行**、**运行配置**和**新建运行配置**。
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.
```
![\[在 AWS Cloud9 IDE 中运行代码后的 Node.js 输出\]](http://docs.aws.amazon.com/zh_cn/cloud9/latest/user-guide/images/ide-nodejs-simple.png)
**注意**
不必在 IDE 中创建新的运行配置，您还可以从终端运行命令 **`node hello.js 5 9`** 以执行此代码。
## 第 4 步：在 Node.js JavaScript 中安装和配置 AWS 开发工具包
您可以增强此示例，使用 Node.js JavaScript 中的 AWS 软件开发工具包创建 Amazon S3 存储桶，列出您的可用存储桶，然后删除您刚刚创建的存储桶。
在此步骤中，您将在 Node.js JavaScript 中安装和配置 AWS 开发工具包。该软件开发工具包提供了一种通过您的 JavaScript 代码与 Amazon S3 等 AWS 服务进行交互的便捷方式。 JavaScript 在 Node.js 中安装 AWS 适用的 SDK 后，您必须在自己的环境中设置凭据管理。SDK 需要这些凭据才能与 AWS 服务进行交互。
### 在 Node.js JavaScript 中安装 AWS 适用的 SDK
在 AWS Cloud9 IDE 的终端会话中，从`hello.js`文件所在的目录中[步骤 3：运行代码](#sample-typescript-run)，运行**`npm`**并 JavaScript 在 Node.js 中安装适用的 AWS SDK。
```
npm install aws-sdk
```
此命令从 [步骤 3：运行代码](#sample-typescript-run) 中向 `node_modules` 文件夹添加多个文件夹。这些文件夹包含 Node.js JavaScript 中 AWS 软件开发工具包的源代码和依赖项。有关更多信息，请参阅[《适用于 JavaScript 的 AWS SDK 开发人员指南》 JavaScript中的安装软件](https://docs.aws.amazon.com/sdk-for-javascript/latest/developer-guide/installing-jssdk.html)*开发*工具包。
### 在环境中设置凭证管理
每次使用 Node.js JavaScript 中的 AWS SDK 调用 AWS 服务时，都必须为调用提供一组凭据。这些凭证确定 Node.js JavaScript 中的 S AWS DK 是否具有进行该调用的相应权限。如果凭证没有包括合适的权限，调用将失败。
在此步骤中，您将凭证存储在环境内。为此，请按照 [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. 在 AWS Cloud9 IDE 的终端中，在`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 步：运行 S AWS DK 代码
1. 在终端中，从与`s3.ts`文件相同的目录中运行 TypeScript 编译器。指定 `s3.ts` 文件以及要包括的其他库。
```
tsc s3.ts --lib es6
```
TypeScript 使用`s3.ts`文件、Node.js JavaScript 中的 AWS SDK、异步库和一组 ECMAScript 6 (ES6) 库文件将文件中的 TypeScript代码转换为名为`s3.ts`的文件中的等效 JavaScript 代码。`s3.js`
1. 在 **Environment (环境)** 窗口中，打开 `s3.js` 文件。
1. 在菜单栏上依次选择**运行**、**运行配置**和**新建运行配置**。
1. 在 **[New] - Idle ([新建] - 空闲)** 选项卡上，选择 **Runner: Auto (运行程序: 自动)**，然后选择 **Node.js**。
1. 在 **Comman** d 中`s3.js YOUR_BUCKET_NAME THE_AWS_REGION `，键入，其中` YOUR_BUCKET_NAME `是您要创建然后删除的存储桶的名称，` THE_AWS_REGION `是要在其中创建存储桶的 AWS 区域的 ID。例如，对于美国东部 (俄亥俄) 区域，请使用 `us-east-2`。欲了解更多信息 IDs，请参阅中的[亚马逊简单存储服务 (Amazon S3) S](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) ervice。*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 开发环境连接到亚马逊 EC2 中亚马逊 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 实例。**此示例假设您的账户中已经有一个运行亚马逊 Linux 或 Ubuntu 服务器的 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，则请安装它。安装 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。为此，请将 ** `yum` ** 命令或 ** `apt` ** 命令与 ** `install` ** 操作一起运行，并指定要安装的 ** `docker` ** 或 ** `docker.io` ** 程序包。
对于 Amazon Linux：
```
sudo yum install -y docker
```
对于 Ubuntu Server：
```
sudo apt install -y docker.io
```
1. 确认已安装 Docker。为此，请再次运行 **`docker --version`** 命令。将显示 Docker 版本和版本号。
1. 运行 Docker。为此，请将 ** `service` ** 命令与 ** `docker` ** 服务和 ** `start` ** 操作一起运行。
```
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`。
**注意**
您可以从 AWS CodeBuild中访问经常更新的 Docker 镜像列表。有关更多信息，请参阅《*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. 打开 AWS Cloud9 控制台，网址为[https://console.aws.amazon.com/cloud9/](https://console.aws.amazon.com/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. 通过将 ** `docker` ** 命令与 ** `build` ** 操作一起运行，将标签 `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` 运行带分配的伪 TTY 的容器并使 STDIN 保持打开状态，即使未附加容器也是如此。
+ `--expose` 使指定端口（此示例中为端口 `9090`）可通过容器使用。
+ `-p` 使指定端口在内部通过指定 IP 地址和端口可供 Amazon EC2 实例使用。在此示例中，可通过 Amazon EC2 实例上的端口 `22` 内部访问容器上的端口 `9090`。
+ `--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` 运行带分配的伪 TTY 的容器并使 STDIN 保持打开状态，即使未附加容器也是如此。
+ `cloud9` 是运行的容器的用户可读名称。
+ `bash` 在运行的容器中启动标准 Shell。
如果成功，则终端提示符将更改为显示登录用户的容器名称和容器 ID。
**注意**
如果您需要从运行的容器注销，请运行 ** `exit` ** 命令。终端提示符将更改回显示登录用户的实例名称和实例的私有 DNS。容器应仍在运行中。
1. 对于正在运行的容器上 AWS Cloud9 要在登录后启动的目录，请将其访问权限设置为**`rwxr-xr-x`**。这意味着所有者的 read-write-execute权限、群组的读取执行权限以及其他人的读取执行权限。例如，如果目录的路径为 `~`，则可以通过在运行的容器中运行 **`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 控制台并创建环境。
+ 确定要连接到环境的现有云计算实例（例如，您的中的 Amazon EC2 实例 AWS 账户）或您 AWS Cloud9 自己的服务器。
+ 确保现有实例或您自己的服务器满足所有 [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 文档](https://lightsail.aws.amazon.com/ls/docs/how-to/article/lightsail-how-to-connect-to-your-instance-virtual-private-server)中的*连接到基于 Linux/Unix 的 Lightsail 实例*。
有关信息 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。已经在 macOS 和 Linux 操作系统上安装了 SSH。要在 Windows 上使用 SSH 连接到服务器，您必须安装 [PuTTY](https://www.putty.org/)。
1. 登录 AWS Cloud9 控制台，网址为[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_cn/cloud9/latest/user-guide/images/consolas_region_new_UX.png)
1. 如果您是第一次创建开发环境，则将显示欢迎页面。在 “**新建 AWS Cloud9 环境**” 面板中，选择 “**创建环境**”。
如果您之前创建过开发环境，您也可以展开屏幕左侧的窗格。选择 **Your environments**（您的环境），然后选择 **Create environment**（创建环境）。
在**欢迎**页面：
![\[如果显示欢迎页面，则选择“Create environment（创建环境）”按钮\]](http://docs.aws.amazon.com/zh_cn/cloud9/latest/user-guide/images/create_welcome_env_new_UX.png)
或在 **Your environment（您的环境）**页面内：
![\[如果未显示欢迎页面，则选择“Create environment（创建环境）”按钮\]](http://docs.aws.amazon.com/zh_cn/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 实例进行交互。您可以在界面下方的 **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 用户指南中的[使用 AWS 资源标签控制访问权限](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html)以及本指南](https://docs.aws.amazon.com/IAM/latest/UserGuide/)*中有关标签的[高级信息](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_cn/cloud9/latest/user-guide/images/cloud9-ide-open.png)
如果未能创建账户，则 AWS Cloud9 控制台顶部会出现一个红色的闪光条。由于您的网络浏览器、 AWS 访问权限、实例或关联网络存在问题，您的账户可能无法创建。您可以在 [AWS Cloud9 故障排除](troubleshooting.md#troubleshooting-env-loading)部分找到有关可能修复导致账户失败问题的信息。
**注意**
如果您的环境使用代理来访问 Internet，则必须向其提供代理详细信息， 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`夹。例如，如果目录为 `~`，请将 ** `rm` ** 命令与 ** `-r` ** 选项一起运行，如下所示。
```
sudo rm -r ~/.c9
```
### 步骤 6.3：删除实例中的 Docker 支持文件
如果您不想再在 Amazon EC2 实例上保留 Docker 容器、Docker 镜像和 Docker，但想要保留此实例，则可删除这些 Docker 支持文件，如下所示。
1. 从实例中删除 Docker 容器。为此，请在实例上将 ** `docker` ** 命令与 ** `stop` ** 和 ** `rm` ** 停止操作以及容器的用户可读名称一起运行。
```
sudo docker stop cloud9
sudo docker rm cloud9
```
1. 从实例中删除 Docker 映像。为此，请在实例上将 **`docker`** 命令与 **`image rm`** 操作和映像的标签一起运行。
```
sudo docker image rm cloud9-image:latest
```
1. 删除可能仍存在的任何其他 Docker 支持文件。为此，请在实例上将 **`docker`** 命令与 **`system prune`** 操作一起运行。
```
sudo docker system prune -a
```
1. 卸载 Docker。为此，请在实例上将 ** `yum` ** 命令与 ** `remove` ** 操作一起运行，以指定要卸载的 ** `docker` ** 程序包。
对于 Amazon Linux：
```
sudo yum -y remove docker
```
对于 Ubuntu Server：
```
sudo apt -y remove docker
```
还可以删除之前创建的 `Dockerfile` 和 `authorized_keys` 文件。例如，在实例上运行 ** `rm` ** 命令。
```
sudo rm /tmp/Dockerfile
sudo rm /tmp/authorized_keys
```
### 步骤 6.4：终止实例
要终止 Amazon EC2 实例，请参阅《Amazon EC2 用户指南》**中的[终止您的实例](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html)。
## 相关教程
+ *AWS RoboMaker 开发者指南 AWS RoboMaker中的@@ [入门](https://docs.aws.amazon.com/robomaker/latest/dg/getting-started.html)指南*。本教程 AWS Cloud9 用于修改、构建和捆绑示例机器人应用程序。