

本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

# 使用 Elastic Beanstalk 部署 Node.js 應用程式
<a name="create_deploy_nodejs"></a>

本章提供設定和部署 Node.js Web 應用程式的說明。 AWS Elastic Beanstalk它還提供常見任務的逐步解說，例如資料庫整合和使用 Express 架構。Elastic Beanstalk 可讓您使用 Amazon Web Services 輕鬆部署、管理和擴展 Node.js Web 應用程式。

您可以使用 Elastic Beanstalk 命令列界面 (EB CLI) 或使用 Elastic Beanstalk 主控台，在幾分鐘內部署應用程式。部署 Elastic Beanstalk 應用程式之後，您可以繼續使用 EB CLI 來管理您的應用程式和環境，也可以使用 Elastic Beanstalk 主控台 AWS CLI或 APIs。

遵循 [適用於 Node.js 的 QuickStart ](nodejs-quickstart.md)的逐步說明，使用 EB CLI 建立和部署 *Hello World* Node.js Web 應用程式。 step-by-step 

**Topics**
+ [QuickStart：將 Node.js 應用程式部署至 Elastic Beanstalk](nodejs-quickstart.md)
+ [設定 Elastic Beanstalk 的 Node.js 開發環境](nodejs-devenv.md)
+ [使用 Elastic Beanstalk Node.js 平台](create_deploy_nodejs.container.md)
+ [更多適用於 Node.js 的 Elastic Beanstalk 範例應用程式和教學課程](nodejs-getstarted.md)
+ [將 Node.js Express 應用程式部署至 Elastic Beanstalk](create_deploy_nodejs_express.md)
+ [使用叢集將 Node.js Express 應用程式部署至 Elastic Beanstalk](nodejs-express-clustering.md)
+ [將 Node.js 應用程式與 DynamoDB 部署到 Elastic Beanstalk](nodejs-dynamodb-tutorial.md)
+ [將 Amazon RDS 資料庫執行個體新增至 Node.js Elastic Beanstalk 環境](create-deploy-nodejs.rds.md)
+ [Node.js 工具和資源](create_deploy_nodejs.resources.md)

# QuickStart：將 Node.js 應用程式部署至 Elastic Beanstalk
<a name="nodejs-quickstart"></a>

本 QuickStart 教學課程將逐步引導您建立 Node.js 應用程式並將其部署至 AWS Elastic Beanstalk 環境。

**不適用於生產用途**  
範例僅用於示範。請勿在生產環境中使用範例應用程式。

**Topics**
+ [AWS 您的帳戶](#nodejs-quickstart-aws-account)
+ [先決條件](#nodejs-quickstart-prereq)
+ [步驟 1：建立 Node.js 應用程式](#nodejs-quickstart-create-app)
+ [步驟 2：在本機執行您的應用程式](#nodejs-quickstart-run-local)
+ [步驟 3：使用 EB CLI 部署 Node.js 應用程式](#nodejs-quickstart-deploy)
+ [步驟 4：在 Elastic Beanstalk 上執行應用程式](#nodejs-quickstart-run-eb-ap)
+ [步驟 5：清除](#go-tutorial-cleanup)
+ [AWS 您應用程式的 資源](#nodejs-quickstart-eb-resources)
+ [後續步驟](#nodejs-quickstart-next-steps)
+ [使用 Elastic Beanstalk 主控台部署](#nodejs-quickstart-console)

## AWS 您的帳戶
<a name="nodejs-quickstart-aws-account"></a>

如果您還不是 AWS 客戶，則需要建立 AWS 帳戶。註冊可讓您存取 Elastic Beanstalk 和其他您需要 AWS 的服務。

如果您已經有 AWS 帳戶，您可以繼續進行 [先決條件](#nodejs-quickstart-prereq)。

### 建立 AWS 帳戶
<a name="nodejs-quickstart-aws-account-procedure"></a>

#### 註冊 AWS 帳戶
<a name="sign-up-for-aws"></a>

如果您沒有 AWS 帳戶，請完成下列步驟來建立一個。

**註冊 AWS 帳戶**

1. 開啟 [https://portal.aws.amazon.com/billing/signup](https://portal.aws.amazon.com/billing/signup)。

1. 請遵循線上指示進行。

   部分註冊程序需接收來電或簡訊，並在電話鍵盤輸入驗證碼。

   當您註冊 時 AWS 帳戶，*AWS 帳戶根使用者*會建立 。根使用者有權存取該帳戶中的所有 AWS 服務 和資源。作為安全最佳實務，請將管理存取權指派給使用者，並且僅使用根使用者來執行[需要根使用者存取權的任務](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks)。

AWS 會在註冊程序完成後傳送確認電子郵件給您。您可以隨時登錄 [https://aws.amazon.com/](https://aws.amazon.com/) 並選擇**我的帳戶**，以檢視您目前的帳戶活動並管理帳戶。

#### 建立具有管理存取權的使用者
<a name="create-an-admin"></a>

註冊 後 AWS 帳戶，請保護 AWS 帳戶根使用者、啟用 AWS IAM Identity Center和建立管理使用者，以免將根使用者用於日常任務。

**保護您的 AWS 帳戶根使用者**

1.  選擇**根使用者**並輸入 AWS 帳戶 您的電子郵件地址，以帳戶擁有者[AWS 管理主控台](https://console.aws.amazon.com/)身分登入 。在下一頁中，輸入您的密碼。

   如需使用根使用者登入的說明，請參閱 *AWS 登入 使用者指南*中的[以根使用者身分登入](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial)。

1. 若要在您的根使用者帳戶上啟用多重要素驗證 (MFA)。

   如需說明，請參閱《*IAM 使用者指南*》中的[為您的 AWS 帳戶 根使用者 （主控台） 啟用虛擬 MFA 裝置](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html)。

**建立具有管理存取權的使用者**

1. 啟用 IAM Identity Center。

   如需指示，請參閱《AWS IAM Identity Center 使用者指南》**中的[啟用 AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html)。

1. 在 IAM Identity Center 中，將管理存取權授予使用者。

   如需使用 IAM Identity Center 目錄 做為身分來源的教學課程，請參閱*AWS IAM Identity Center 《 使用者指南*》中的[使用預設值設定使用者存取 IAM Identity Center 目錄](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html)。

**以具有管理存取權的使用者身分登入**
+ 若要使用您的 IAM Identity Center 使用者簽署，請使用建立 IAM Identity Center 使用者時傳送至您電子郵件地址的簽署 URL。

  如需使用 IAM Identity Center 使用者登入的說明，請參閱*AWS 登入 《 使用者指南*》中的[登入 AWS 存取入口網站](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html)。

**指派存取權給其他使用者**

1. 在 IAM Identity Center 中，建立一個許可集來遵循套用最低權限的最佳實務。

   如需指示，請參閱《AWS IAM Identity Center 使用者指南》**中的[建立許可集](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html)。

1. 將使用者指派至群組，然後對該群組指派單一登入存取權。

   如需指示，請參閱《AWS IAM Identity Center 使用者指南》**中的[新增群組](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html)。

## 先決條件
<a name="nodejs-quickstart-prereq"></a>

為了遵循本指南的程序，您需要命令列終端機或 shell 來執行命令。命令清單前會出現提示字元 (\$1) 及目前的目錄名稱 (如有)。

```
~/eb-project$ this is a command
this is output
```

在 Linux 和 macOS 上，您可以使用偏好的 Shell 和套件軟體管理工具。在 Windows [上，您可以安裝適用於 Linux 的 Windows 子系統](https://docs.microsoft.com/en-us/windows/wsl/install-win10)，以取得與 Windows 整合的 Ubuntu 和 Bash 版本。

### EB CLI
<a name="nodejs-quickstart-prereq.ebcli"></a>

本教學使用 Elastic Beanstalk 命令列界面 (EB CLI)。關於安裝和設定 EB CLI 的詳細資訊，請參閱[使用設定指令碼安裝 EB CLI （建議）](eb-cli3.md#eb-cli3-install) 和[設定 EB CLI](eb-cli3-configuration.md)。

### Node.js
<a name="nodejs-quickstart-prereq.runtime"></a>

遵循 Node.js 網站上的[如何安裝 Node.js，在您的本機電腦上安裝](https://nodejs.org/en/learn/getting-started/how-to-install-nodejs) Node.js。

執行下列命令來驗證您的 Node.js 安裝。

```
~$ node -v
```

## 步驟 1：建立 Node.js 應用程式
<a name="nodejs-quickstart-create-app"></a>

建立專案目錄。

```
~$ mkdir eb-nodejs
~$ cd eb-nodejs
```

接著，請建立您將使用 Elastic Beanstalk 進行部署的應用程式。我們將建立一個「Hello World」RESTful Web 服務。

**Example `~/eb-nodejs/server.js`**  

```
const http = require('node:http');

const hostname = '127.0.0.1';
const port = 8080;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello Elastic Beanstalk!\n');
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});
```

此應用程式會在連接埠 8080 上開啟接聽程式。Elastic Beanstalk 預設會將 Node.js 的請求轉送至連接埠 8080 上的應用程式。

## 步驟 2：在本機執行您的應用程式
<a name="nodejs-quickstart-run-local"></a>

執行下列命令以在本機執行您的應用程式。

```
~/eb-nodejs$ node server.js
```

您應該會看到下列文字。

```
Server running at http://127.0.0.1:8080/
```

在 Web 瀏覽器`http://127.0.0.1:8080/`中輸入 URL 地址。瀏覽器應該顯示「Hello Elastic Beanstalk！」。

## 步驟 3：使用 EB CLI 部署 Node.js 應用程式
<a name="nodejs-quickstart-deploy"></a>

執行下列命令，為此應用程式建立 Elastic Beanstalk 環境。

**建立環境並部署 Node.js 應用程式**

1. 透過 **eb init** 命令初始化您的 EB CLI 儲存庫。

   ```
   ~/eb-nodejs$ eb init -p node.js nodejs-tutorial --region us-east-2
   ```

   此命令會建立名為 的應用程式，`nodejs-tutorial`並設定您的本機儲存庫，以使用最新的 Node.js 平台版本建立環境。

1. (選用) 再次執行 **eb init** 來設定預設金鑰對，藉此使用 SSH 連接至執行您應用程式的 EC2 執行個體：

   ```
   ~/eb-nodejs$ eb init
   Do you want to set up SSH for your instances?
   (y/n): y
   Select a keypair.
   1) my-keypair
   2) [ Create new KeyPair ]
   ```

   若您已有金鑰對，請選擇一對，或依照提示建立金鑰對。若未出現提示，或稍後需要變更設定，請執行 **eb init -i**。

1. 使用 **eb create** 建立環境並於其中部署您的應用程式。Elastic Beanstalk 會自動為您的應用程式建置 zip 檔案，並將其部署到環境中的 EC2 執行個體。部署應用程式之後，Elastic Beanstalk 會在連接埠 8080 上啟動應用程式。

   ```
   ~/eb-nodejs$ eb create nodejs-env
   ```

   Elastic Beanstalk 大約需要五分鐘的時間來建立您的環境。

## 步驟 4：在 Elastic Beanstalk 上執行應用程式
<a name="nodejs-quickstart-run-eb-ap"></a>

當建立環境的程序完成時，請使用 開啟您的網站**eb open**。

```
~/eb-nodejs$ eb open
```

恭喜您！您已使用 Elastic Beanstalk 部署 Node.js 應用程式！這會開啟瀏覽器視窗，並使用為應用程式建立的網域名稱。

## 步驟 5：清除
<a name="go-tutorial-cleanup"></a>

您可以在完成使用應用程式時終止您的環境。Elastic Beanstalk 會終止與您的環境相關聯的所有 AWS 資源。

若要使用 EB CLI 終止 Elastic Beanstalk 環境，請執行下列命令。

```
~/eb-nodejs$ eb terminate
```

## AWS 您應用程式的 資源
<a name="nodejs-quickstart-eb-resources"></a>

您剛建立單一執行個體應用程式。它可作為具有單一 EC2 執行個體的簡單範例應用程式，因此不需要負載平衡或自動擴展。對於單一執行個體應用程式，Elastic Beanstalk 會建立下列 AWS 資源：
+ **EC2 執行個體** – 設定在您所選平台上執行 Web 應用程式的 Amazon EC2 虛擬機器。

  每個平台會執行不同一套軟體、設定檔和指令碼，來支援特定的語言版本、架構、Web 容器或其組合。大多數的平台會使用 Apache 或 nginx 做為反向代理，處理您 Web 應用程式前端的網路流量、向它轉送請求、提供靜態資產，並產生存取和錯誤日誌。
+ **執行個體安全群組** – 設定允許從連接埠 80 傳入流量的 Amazon EC2 安全群組。此資源可讓負載平衡器傳來的 HTTP 傳輸資料，到達執行您 Web 應用程式的 EC2 執行個體。在預設情況下，不允許傳輸資料從其他通訊埠傳送。
+ **Amazon S3 儲存貯體** - 儲存位置，用來儲存當您使用 Elastic Beanstalk 時所建立的原始程式碼、日誌和其他成品。
+ **Amazon CloudWatch 警示** – 兩種 CloudWatch 警示，用來監控您環境中執行個體上的負載，會在負載過高或過低時觸發。當警示觸發時，您的 Auto Scaling 群組會擴展或縮減以進行回應。
+ **CloudFormation 堆疊** – Elastic Beanstalk 使用 CloudFormation 啟動環境中的資源並傳播組態變更。資源定義於範本中，您可在 [CloudFormation 主控台](https://console.aws.amazon.com/cloudformation)中檢視此範本。
+  **網域名稱** – 會路由到您 Web 應用程式的網域名稱，其格式為 **subdomain*.*region*.elasticbeanstalk.com*。

Elastic Beanstalk 會管理所有這些資源。當您終止環境時，Elastic Beanstalk 會終止其中的所有資源。

## 後續步驟
<a name="nodejs-quickstart-next-steps"></a>

在您擁有執行應用程式的環境後，可以隨時部署應用程式的新版本或不同的應用程式。部署新的應用程式版本非常快速，因無須佈建或重新啟動 EC2 執行個體。您也可以使用 Elastic Beanstalk 主控台探索您的新環境。如需詳細步驟，請參閱本指南*入門*章節中的[探索您的環境](GettingStarted.md#GettingStarted.Explore)。

**嘗試更多教學課程**  
如果您想要使用不同的範例應用程式來嘗試其他教學課程，請參閱 [更多適用於 Node.js 的 Elastic Beanstalk 範例應用程式和教學課程](nodejs-getstarted.md)。

部署範例應用程式一兩個，並準備好開始在本機開發和執行 Node.js 應用程式後，請參閱 [設定 Elastic Beanstalk 的 Node.js 開發環境](nodejs-devenv.md)。

## 使用 Elastic Beanstalk 主控台部署
<a name="nodejs-quickstart-console"></a>

您也可以使用 Elastic Beanstalk 主控台來啟動範例應用程式。如需詳細步驟，請參閱本指南*入門*章節中的[建立範例應用程式](GettingStarted.md#GettingStarted.CreateApp)。

# 設定 Elastic Beanstalk 的 Node.js 開發環境
<a name="nodejs-devenv"></a>

本主題提供在部署到 之前，設定 Node.js 開發環境以在本機測試應用程式的指示 AWS Elastic Beanstalk。它還參考提供實用工具安裝說明的網站。

**Topics**
+ [安裝 Node.js。](#nodejs-devenv-nodejs)
+ [確認 npm 安裝](#nodejs-devenv-npm)
+ [安裝適用於 Node.js 的 AWS SDK](#nodejs-devenv-awssdk)
+ [安裝 Express 產生器](#nodejs-devenv-express)
+ [設定 Express 架構與伺服器](#nodejs-devenv-express-framework)

## 安裝 Node.js。
<a name="nodejs-devenv-nodejs"></a>

安裝 Node.js 以於本機執行 Node.js 應用程式。若您沒有特別需求，請取得 Elastic Beanstalk 支援的最新版本。如需支援版本的清單，請參閱 *AWS Elastic Beanstalk 平台*文件中的 [Node.js](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs)。

至 [nodejs.org](https://nodejs.org/en/) 下載 Node.js。

## 確認 npm 安裝
<a name="nodejs-devenv-npm"></a>

Node.js 使用 npm 套裝管理員，助您安裝欲在應用程式使用的工具及架構。由於 npm 與 Node.js 一起分發，您將在下載並安裝 Node.js 時自動對其進行安裝。要確認您已安裝 npm，您可以運行以下命令：

```
$ npm -v
```

有關 npm 的更多信息，請瀏覽 [npmjs](https://www.npmjs.com/get-npm) 網站。

## 安裝適用於 Node.js 的 AWS SDK
<a name="nodejs-devenv-awssdk"></a>

如果您需要從應用程式中管理 AWS 資源，請在 Node.js 中安裝適用於 JavaScript 的 AWS SDK。使用 npm 安裝 SDK：

```
$ npm install aws-sdk
```

如需詳細資訊，請造訪[適用於 Node.js 中 JavaScript 的AWS 開發套件](https://aws.amazon.com/sdk-for-node-js/)首頁。

## 安裝 Express 產生器
<a name="nodejs-devenv-express"></a>

Express 為執行 Node.js 的 Web 應用程式架構。若要使用，請先安裝 Express 產生器命令列應用程式。安裝 Express 產生器後，即可執行 **express** 命令，為您的 Web 應用程式產生基本專案結構。安裝基礎專案、檔案和相依性後，即可在開發機器上啟動本機 Express 伺服器。

 

**注意**  
下列步驟將引導您在 Linux 作業系統上安裝 Express 產生器。
對於 Linux，根據您的系統目錄許可層級，您可能需要透過 `sudo` 為部分命令增加字首。

**在開發環境中安裝 Express 產生器**

1. 為您的 Express 架構和伺服器建立工作目錄。

   ```
   ~$ mkdir node-express
   ~$ cd node-express
   ```

1. 全面安裝 Express，讓您能夠存取 `express` 命令。

   ```
   ~/node-express$ npm install -g express-generator
   ```

1. 依據您的作業系統而定，可能需要設定路徑以執行 `express` 命令。如果您需要設定路徑變數，上一個步驟的輸出可提供相關資訊。以下是 Linux 範例。

   ```
   ~/node-express$ export PATH=$PATH:/usr/local/share/npm/bin/express
   ```

   若您遵循本章的教學課程，您將需要從不同的目錄執行 **express** 命令。每個教學課程都會在其自身目錄中設置基本 Express 專案結構。

您現在已經安裝 Express 命令列產生器。您可以用其為 Web 應用程式建立架構目錄、設定相依性，以及啟動 Web 應用程式伺服器。接下來，我們將執行步驟，在建立的 `node-express` 目錄中達成此目標。

## 設定 Express 架構與伺服器
<a name="nodejs-devenv-express-framework"></a>

請依照下列步驟建立基本 Express 架構目錄和內容。本章教學課程也包含此類步驟，以便在每個教學課程的應用程式目錄中設定基本 Express 架構。

**設定 Express 架構與伺服器**

1. 執行 `express` 命令。這會產生 `package.json`、`app.js` 以及幾個目錄。

   ```
   ~/node-express$ express
   ```

   當提示您是否要繼續時，請輸入 **y**。

1. 設定本機依存項目。

   ```
   ~/node-express$ npm install
   ```

1. 確認 Web 應用程式伺服器已啟動。

   ```
   ~/node-express$ npm start
   ```

   您應該會看到類似下列的輸出：

   ```
   > nodejs@0.0.0 start /home/local/user/node-express
   > node ./bin/www
   ```

   依預設，伺服器將會在連接埠 3000 上執行。若要進行測試，請在另一部終端機上執行 `curl http://localhost:3000`，或在本機電腦開啟瀏覽器並輸入 URL 位址 `http://localhost:3000`。

   按 **Ctrl\$1C** 來停止伺服器。

# 使用 Elastic Beanstalk Node.js 平台
<a name="create_deploy_nodejs.container"></a>

本主題說明如何在 Elastic Beanstalk 上設定、建置和執行 Node.js 應用程式。

AWS Elastic Beanstalk 支援多個不同版本的 Node.js 程式設計語言平台分支。如需完整清單，請參閱 *AWS Elastic Beanstalk 平台文件中的* [Node.js](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs)。

Elastic Beanstalk 提供[組態選項](command-options.md)，您可以用來自訂在 Elastic Beanstalk 環境中 EC2 執行個體上執行的軟體。您可以設定應用程式所需的[環境變數](environments-cfg-softwaresettings.md#environments-cfg-softwaresettings-console)，啟用 Amazon S3 的日誌輪換，並將包含靜態檔案的應用程式來源中的資料夾映射到代理伺服器提供的路徑。

Elastic Beanstalk 主控台中提供了[修改正在執行環境組態](environment-configuration-methods-after.md)的組態選項。要避免在終止環境的組態時遺失組態，您可以使用[已儲存組態](environment-configuration-savedconfig.md)來儲存您的設定，並在之後套用至另一個環境。

若要將設定儲存於原始程式碼，您可以包含[組態檔案](ebextensions.md)。每次您建立環境或部署應用程式，組態檔案裡的設定就會套用。您也可以使用組態檔案來安裝套件、執行指令碼，並在部署期間執行其他執行個體自訂操作。

您可以在原始碼套件中[包含一個 `Package.json` 檔案](nodejs-platform-dependencies.md#nodejs-platform-packagejson)，以便在部署期間安裝套件、提供啟動命令，以及指定您希望應用程式使用的 Node.js 版本。您可以包含一個 [`npm-shrinkwrap.json` 檔案](nodejs-platform-shrinkwrap.md)來鎖定相依性版本。

Node.js 平台包含一個代理伺服器，以為靜態資產提供服務、將流量轉發至您的應用程式，以及壓縮回應資料。您可以針對進階的應用情境，來[擴展或覆寫預設的代理組態](nodejs-platform-proxy.md)。

有幾個選項可以啟動您的應用程序。您可以將 [Procfile](nodejs-configuration-procfile.md) 新增到原始碼套件中，以指定啟動應用程式的命令。如果您未提供 `Procfile` 但提供 `package.json` 檔案，則 Elastic Beanstalk 會執行 `npm start`。如果您也沒有提供該檔案，則 Elastic Beanstalk 會依序尋找 `app.js` 或 `server.js` 檔案，並執行程式碼。

在 Elastic Beanstalk 主控台中套用的設定會覆寫組態檔案中相同的設定 (如存在)。這可讓您在組態檔案中擁有預設設定，並以主控台的環境專屬設定覆寫之。如需優先順序以及其他變更設定方法的詳細資訊，請參閱[組態選項](command-options.md)。

如需各種擴充 Elastic Beanstalk Linux 類型平台方式的詳細資訊，請參閱 [擴充 Elastic Beanstalk Linux 平台](platforms-linux-extend.md)。

## 設定您的 Node.js 環境
<a name="nodejs-platform-console"></a>

您可以使用 Node.js 平台設定來微調 Amazon EC2 執行個體的行為。您可以使用 Elastic Beanstalk 主控台編輯 Elastic Beanstalk 環境的 Amazon EC2 執行個體組態。

使用 Elastic Beanstalk 主控台來啟用至 Amazon S3 的日誌輪換，和設定您的應用程式可以從環境讀取的變數。

**在 Elastic Beanstalk 主控台中設定 Node.js 環境**

1. 開啟 [Elastic Beanstalk 主控台](https://console.aws.amazon.com/elasticbeanstalk)，然後在**區域**清單中選取您的 AWS 區域。

1. 在導覽窗格中，選擇**環境**，然後在清單中選擇您環境的名稱。

1. 在導覽窗格中，選擇**組態**。

1. 在**更新、監控和日誌記錄**組態類別中，選擇**編輯**。

### 容器選項
<a name="nodejs-platform-console-settings"></a>

您可以指定這些平台特有的選項：
+ **代理伺服器** – 要在您的環境執行個體上使用的代理伺服器。預設為使用 NGINX。

### 日誌選項
<a name="nodejs-platform-console-logging"></a>

**Log Options (日誌選項)** 區段有兩個設定：
+ **Instance profile** (執行個體描述檔) – 指定執行個體描述檔，此描述檔具有的許可，可存取和您應用程式相關的 Amazon S3 儲存貯體。
+ **Enable log file rotation to Amazon S3** (啟用 Amazon S3 的日誌檔案輪換) – 指定是否將應用程式 Amazon EC2 執行個體的日誌檔案複製到與應用程式關聯的 Amazon S3 儲存貯體。

### 靜態檔案
<a name="nodejs-platform-console-staticfiles"></a>

為改善效能，您可以使用 **Static files** (靜態檔案) 區段來設定代理伺服器，以為來自 Web 應用程式一組目錄中的靜態檔案 (例如 HTML 或影像) 提供服務。對於每個目錄，您可以設定目錄映射的虛擬路徑。代理伺服器收到位於指定路徑下的檔案請求時，會直接提供檔案而非將請求路由至您的應用程式。

如需使用組態檔案或 Elastic Beanstalk 主控台設定靜態檔案的詳細資訊，請參閱[提供靜態檔案](environment-cfg-staticfiles.md)。

### 環境屬性
<a name="nodejs-platform-console-envprops"></a>

使用 **Environment Properties** (環境屬性) 部分針對執行您應用程式的 Amazon EC2 執行個體，來指定其上的環境資訊設定。這些設定會以金鑰值對的形式傳到應用程式。

在 中執行Node.js的環境中 AWS Elastic Beanstalk，您可以透過執行 來存取環境變數`process.env.ENV_VARIABLE`。

```
var endpoint = process.env.API_ENDPOINT
```

Node.js 平台會將 PORT 環境變數設定為代理伺服器傳送流量至其中的連接埠。如需詳細資訊，請參閱[設定代理伺服器](nodejs-platform-proxy.md)。

如需詳細資訊，請參閱[環境變數和其他軟體設定](environments-cfg-softwaresettings.md)。

### 設定 Amazon Linux AMI (先前的 Amazon Linux 2) Node.js 環境
<a name="nodejs-platform-console.alami"></a>

只有使用 Amazon Linux AMI 平台版本 (先前的 Amazon Linux 2) 的 Elastic Beanstalk Node.js 環境才支援以下主控台軟體組態類別。

**備註**  
本主題中的資訊僅適用於以 Amazon Linux AMI (AL1) 為基礎的平台分支。AL2023/AL2 平台分支與舊版 Amazon Linux AMI (AL1) 平台版本不相容，*需要不同的組態設定*。
 在 [2022 年 7 月 18 日，](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html)Elastic Beanstalk 會根據 Amazon Linux AMI (AL1) 將所有平台分支的狀態設定為**已淘汰**。如需有關遷移至完全支援的目前 Amazon Linux 2023 平台分支的詳細資訊，請參閱 [將您的 Elastic Beanstalk Linux 應用程式遷移到 Amazon Linux 2023 或 Amazon Linux 2](using-features.migration-al.md)。

#### 容器選項 — Amazon Linux AMI (AL1)
<a name="nodejs-platform-console-settings"></a>

在組態頁面上指定下列項目：
+ **Proxy server** (代理伺服器) – 指定要使用哪一個 Web 伺服器來將代理連線連至 Node.js。預設為使用 NGINX。如果選擇 **none** (無)，則靜態檔案映射不會生效，而且會停用 GZIP 壓縮功能。
+ **Node.js 版本** – 指定 Node.js 的版本。如需支援的 Node.js 版本清單，請參閱 *AWS Elastic Beanstalk 平台指南*中的 [https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs)。
+ **GZIP 壓縮** – 指定是否啟用 GZIP 壓縮。預設為啟用 GZIP 壓縮。
+ **Node command** (節點命令) – 讓您能輸入用來啟動 Node.js 應用程式的命令。空白字串 (預設值) 表示 Elastic Beanstalk 將會依序使用 `app.js`、`server.js` 和 `npm start`。

## Node.js 組態命名空間
<a name="nodejs-namespaces"></a>

您可以使用[組態檔案](ebextensions.md)來設定組態選項，並在部署期間執行其他的執行個體設定工作。組態選項可以是[平台特定](command-options-specific.md)選項，也可以套用至 Elastic Beanstalk 服務整體中的所有[平台](command-options-general.md)。組態選項會組織成*命名空間*。

您可以使用 `aws:elasticbeanstalk:environment:proxy` 命名空間來選擇要在環境的執行個體上使用的代理。以下範例會將您的環境設定為使用 Apache HTTPD 代理伺服器。

**Example .ebextensions/nodejs-settings.config**  

```
option_settings:
  aws:elasticbeanstalk:environment:proxy:
    ProxyServer: apache
```

您可以使用 `aws:elasticbeanstalk:environment:proxy:staticfiles` 命名空間設定代理提供靜態檔案。如需詳細資訊和範例，請參閱 [提供靜態檔案](environment-cfg-staticfiles.md)。

Elastic Beanstalk 可提供許多組態選項讓您自訂環境。除了組態檔案，您也可以使用主控台、已儲存組態、EB CLI 或 AWS CLI來設定組態選項。如需詳細資訊，請參閱[組態選項](command-options.md)。

## Amazon Linux AMI (先前的 Amazon Linux 2) Node.js 平台
<a name="nodejs.alami"></a>

如果您的 Elastic Beanstalk Node.js 環境使用 Amazon Linux AMI 平台版本 (先前的 Amazon Linux 2)，請考慮本節中的特定組態和建議。

**備註**  
本主題中的資訊僅適用於以 Amazon Linux AMI (AL1) 為基礎的平台分支。AL2023/AL2 平台分支與舊版 Amazon Linux AMI (AL1) 平台版本不相容，*需要不同的組態設定*。
 在 [2022 年 7 月 18 日，](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html)Elastic Beanstalk 會根據 Amazon Linux AMI (AL1) 將所有平台分支的狀態設定為**已淘汰**。如需有關遷移至完全支援的目前 Amazon Linux 2023 平台分支的詳細資訊，請參閱 [將您的 Elastic Beanstalk Linux 應用程式遷移到 Amazon Linux 2023 或 Amazon Linux 2](using-features.migration-al.md)。

### Node.js 平台特定組態選項 — Amazon Linux AMI (AL1)
<a name="nodejs.alami.options"></a>

Elastic Beanstalk 支援適用於 Amazon Linux AMI Node.js 平台版本的一些平台特定組態。您可以選擇要在應用程式前景執行的代理伺服器、選擇要執行的特定 Node.js 版本，並選擇用來執行應用程式的命令。

對於代理伺服器，您可以使用 NGINX 或 Apache 代理伺服器。您可以將 `none` 值設定為 `ProxyServer` 選項。使用此設定，Elastic Beanstalk 會獨立執行您的應用程式，而不會在任何代理伺服器後方執行。如果您的環境執行獨立應用程式，請更新您的程式碼以接聽 NGINX 將流量轉發至其中的連接埠。

```
var port = process.env.PORT || 8080;

app.listen(port, function() {
  console.log('Server running at http://127.0.0.1:%s', port);
});
```

### Node.js 語言版本 — Amazon Linux AMI (AL1)
<a name="nodejs.alami.versions"></a>

在支援的語言版本方面，Node.js Amazon Linux AMI 平台與其他由 Elastic Beanstalk 管理的平台不同。這是因為每個 Node.js 平台版本僅支援幾個 Node.js 語言版本。如需支援的 Node.js 版本清單，請參閱 *AWS Elastic Beanstalk 平台指南*中的 [https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs)。

您可以使用平台特定的組態選項來設定語言版本。如需說明，請參閱[設定您的 Node.js 環境](#nodejs-platform-console)。或者，使用 Elastic Beanstalk 主控台來更新您的環境使用的 Node.js 版本，作為更新平台版本的一部分。

**注意**  
如果您所使用的 Node.js 版本的支援已從平台移除，您必須在[平台更新](using-features.platform.upgrade.md)之前變更或移除版本設定。當發現一個或多個版本的 Node.js 存在安全漏洞時，可能會出現此種狀況。  
此時，如果嘗試將不支援已設定 [NodeVersion](command-options-specific.md#command-options-nodejs) 的平台更新至新版本，此動作將會失敗。為省去建立新環境的必要，請將 *NodeVersion* 組態選項變更為新舊平台版本皆支援的 Node.js 版本，或是[移除選項設定](environment-configuration-methods-after.md)，然後執行平台更新。

**在 Elastic Beanstalk 主控台中設定環境的 Node.js 版本**

1. 開啟 [Elastic Beanstalk 主控台](https://console.aws.amazon.com/elasticbeanstalk)，然後在**區域**清單中選取您的 AWS 區域。

1. 在導覽窗格中，選擇**環境**，然後在清單中選擇您環境的名稱。

1. 在環境概觀頁面的 **Platform (平台)** 下，選擇 **Change (變更)**。

1. 在 **Update platform version** (更新平台版本) 對話方塊中，選取 Node.js 平台版本。  
![\[Elastic Beanstalk 更新平台版本確認\]](http://docs.aws.amazon.com/zh_tw/elasticbeanstalk/latest/dg/images/platform-nodejs-update-node-version.png)

1. 選擇 **Save** (儲存)。

### Node.js 組態命名空間 — Amazon Linux AMI (AL1)
<a name="nodejs.alami.namespaces"></a>

Node.js Amazon Linux AMI 平台在 `aws:elasticbeanstalk:container:nodejs:staticfiles` 和 `aws:elasticbeanstalk:container:nodejs` 命名空間中定義其他選項。

下列組態檔案會告知 Elastic Beanstalk 使用 `npm start` 來執行應用程式。還將代理類型設定為 Apache 並啟用壓縮。最後，它設定代理從兩個來源目錄提供靜態檔案。其中一個來源是來自 `statichtml` 來源目錄，在網站根目錄下 `html` 路徑中的 HTML 檔案。另一個來源是來自 `staticimages` 來源目錄的網站根目錄下的 `images` 路徑的映像檔案。

**Example .ebextensions/node-settings.config**  

```
option_settings:
  aws:elasticbeanstalk:container:nodejs: 
    NodeCommand: "npm start"
    ProxyServer: apache
    GzipCompression: true
  aws:elasticbeanstalk:container:nodejs:staticfiles:
    /html: statichtml
    /images: staticimages
```

Elastic Beanstalk 可提供許多組態選項讓您自訂環境。除了組態檔案，您也可以使用主控台、已儲存組態、EB CLI 或 AWS CLI來設定組態選項。如需詳細資訊，請參閱[組態選項](command-options.md)。

# 在 Elastic Beanstalk Procfile上使用 設定自訂啟動命令
<a name="nodejs-configuration-procfile"></a>

您可以在原始碼套件的根目錄中包含名為 `Procfile` 的檔案，以指定啟動應用程序的命令。

**Example Procfile**  

```
web: node index.js
```

如需`Procfile`用量的相關資訊，請參閱 [Buildfile 和 Procfile](platforms-linux-extend.build-proc.md)。

**注意**  
此功能會取代 `aws:elasticbeanstalk:container:nodejs` 命名空間中的舊版 `NodeCommand` 選項。

# 在 Elastic Beanstalk 上設定應用程式的相依性
<a name="nodejs-platform-dependencies"></a>

您的應用程式可能與一些 Node.js 模組有相依性，例如您在 `require()` 陳述式中指定的模組。這些模組儲存在 `node_modules` 目錄中。當您的應用程式執行時，Node.js 會從此目錄載入模組。如需詳細資訊，請參閱 Node.js 文件中的[從 node\$1modules 資料夾載入](https://nodejs.org/api/modules.html#modules_loading_from_node_modules_folders)。

您可以使用 `package.json` 檔案來指定這些模組相依性。如果 Elastic Beanstalk 偵測到此檔案且 `node_modules` 目錄不存在，Elastic Beanstalk 會以 *webapp* 使用者的身分執行 `npm install`。`npm install` 命令將相依性安裝在 Elastic Beanstalk 事先建立的 `node_modules` 目錄中。`npm install` 命令會從公共 npm 登錄檔或其他位置存取 `package.json` 檔案中列出的套件。如需詳細資訊，請參閱 [npm Docs](https://docs.npmjs.com/about-the-public-npm-registry) 網站。

如果 Elastic Beanstalk 偵測到 `node_modules` 目錄，則即使有 `package.json` 檔案，Elastic Beanstalk 也不會執行 `npm install`。Elastic Beanstalk 假設 `node_modules` 目錄中有可用的相依性套件，以供 Node.js 存取和載入。

以下章節提供為應用程式建立 Node.js 模組相依性的詳細資訊。

**注意**  
如果您在 Elastic Beanstalk 執行 `npm install` 時遭遇任何部署問題，請考慮使用其他方法。將 `node_modules` 目錄以及相依性模組納入您的應用程式原始碼套件中。這樣做可以避免在排查問題時，安裝來自公共 npm 登錄檔的相依性的問題。而由於相依性模組來自本機目錄，所以這可能也有助於縮短部署時間。如需詳細資訊，請參閱[在 a node\$1modules 目錄中納入 Node.js 相依性](#nodejs-platform-nodemodules)

## 使用 package.json 檔案指定 Node.js 相依性
<a name="nodejs-platform-packagejson"></a>

將 `package.json` 檔案包含在專案來源根目錄中來指定相依性套件並提供啟動命令。當有 `package.json` 檔案存在且您專案來源的根目錄中沒有 `node_modules` 目錄時，Elastic Beanstalk 會以 *webapp* 使用者的身分執行 `npm install`，以安裝來自公共 npm 登錄檔的相依性。Elastic Beanstalk 也會使用 `start` 命令來啟動您的應用程式。如需有關 `package.json` 檔案的詳細資訊，請參閱 *npm Docs* 網站中的《[在 `package.json` 檔案中指定相依性](https://docs.npmjs.com/specifying-dependencies-and-devdependencies-in-a-package-json-file)》。

使用 `scripts` 關鍵字來提供啟動命令。現在，在 `aws:elasticbeanstalk:container:nodejs` 命名空間中使用 `scripts` 關鍵字來取代舊版的 `NodeCommand` 選項。

**Example package.json – Express**  

```
{
    "name": "my-app",
    "version": "0.0.1",
    "private": true,
    "dependencies": {
      "ejs": "latest",
      "aws-sdk": "latest",
      "express": "latest",
      "body-parser": "latest"
    },
    "scripts": {
      "start": "node app.js"
    }
  }
```

**生產模式和開發相依性**  
若要在 `package.json` 檔案中指定相依性，請使用 *dependencies* 和 *devDependencies* 屬性。*dependencies* 屬性可指定生產中應用程式所需的套件。*devDependencies* 屬性可指定只需要用於本機開發與測試的套件。

如果您需要安裝 *devDependencies* 套件，請將 PM\$1USE\$1PRODUCTION 環境屬性設為 `false`。透過此設定，我們不會在執行 npm 安裝時使用上述選項。這將導致安裝 *devDependencies* 套件。

## 在 a node\$1modules 目錄中納入 Node.js 相依性
<a name="nodejs-platform-nodemodules"></a>

若要將相依性套件與應用程式程式碼一起部署至環境執行個體，請將它們包含在專案來源根中名為 `node_modules` 的目錄內。如需詳細資訊，請參閱 *npm Docs* 網站中的《[在本機下載和安裝套件](https://docs.npmjs.com/downloading-and-installing-packages-locally)》。

當您將`node_modules`目錄部署到 AL2023/AL2 Node.js平台版本時，Elastic Beanstalk 會假設您提供自己的相依性套件，並避免安裝 [package.json](#nodejs-platform-packagejson) 檔案中指定的相依性。 會在 `node_modules` 目錄中Node.js尋找相依性。如需詳細資訊，請參閱 Node.js 文件中的[從 node\$1modules 資料夾載入](https://nodejs.org/api/modules.html#modules_loading_from_node_modules_folders)。

**注意**  
如果您在 Elastic Beanstalk 執行 `npm install` 時遭遇任何部署問題，在調查問題時，請考慮使用本主題中描述的方法作為變通措施。  
 

### Amazon Linux 2 上的 Node.js 考量事項
<a name="nodejs-al2-considerations"></a>

如果您使用在 *Amazon Linux 2* 上執行的 *Node.js* 平台分支，請閱讀本節。

#### Amazon Linux 2 上的 Node.js 考量事項
<a name="nodejs-al2-considerations-detail"></a>

**注意**  
本主題中的資訊適用於在 Amazon Linux 2 上執行的Node.js平台分支。此處的內容說明與 AL2-specific功能和行為。 AL2023

**命令變化**  
命令選項會根據應用程式執行所在的 Amazon Linux 2 平台分支上包含的 npm 版本而有所不同。
+ npm v6 — 在預設情況下，Elastic Beanstalk 會在生產模式中安裝相依性。其使用命令 `npm install --production`。
+ npm v7 或更高版本 — Elastic Beanstalk 會省略 *devDependencies*。其使用命令 `npm install --omit=dev`。

上述兩個命令都不會安裝屬於 *devDependencies* 的套件。

**Git 相依性的 SSH 和 HTTPS 通訊協定**  
從 2023 年 3 月 7 日開始，您可以使用 SSH 和 HTTPS 通訊協定從 Git 儲存庫擷取套件。平台分支 Node.js 16 同時支援 SSH 和 HTTPS 通訊協定。Node.js 14 僅支援 HTTPS 通訊協定。

**Example package.json – Node.js 16 同時支援 HTTPS 和 SSH**  

```
    ...
    "dependencies": {
      "aws-sdk": "https://github.com/aws/aws-sdk-js.git",
      "aws-chime": "git+ssh://git@github.com:aws/amazon-chime-sdk-js.git"
    }
```

**版本和版本範圍**  
在 `package.json` 檔案中使用 `engines` 關鍵字，來指定您希望應用程式使用的 Node.js 版本。您也可以使用 npm 標記法指定版本範圍。如需有關版本範圍語法的詳細資訊，請參閱 Node.js 網站上的 [Semantic Versioning using npm](https://nodejs.dev/learn/semantic-versioning-using-npm) (使用 npm 的語意版本控制)。Node.js `package.json` 檔案中的 `engines` 關鍵字取代 `aws:elasticbeanstalk:container:nodejs` 命名空間中的舊版 `NodeVersion` 選項。

**重要**  
指定版本範圍的功能不適用於在 AL2023 上執行的 Node.js 平台分支。在 AL2023 上特定的 Node.js 分支內，只支援一個 Node.js 版本。如果 `package.json` 檔案指定了版本範圍，我們將予以忽略，並預設為 Node.js 的平台分支版本。

**Example `package.json` –單一 Node.js 版本**  

```
{
    ...
    "engines": { "node" : "14.16.0" }
  }
```

**Example `package.json` – Node.js 版本範圍**  

```
{
    ...
    "engines": { "node" : ">=10 <11" }
  }
```

在有指出版本範圍的情況下，Elastic Beanstalk 會安裝平台在範圍內可用的最新 Node.js 版本。在此範例中，範圍指出版本必須大於或等於版本 10，但小於版本 11。因此，Elastic Beanstalk 會安裝最新的 Node.js 版本 10.x.y，可在《[支援的平台](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs)》上取得此版本。

請注意，您只能指定一個與您平台分支對應的 Node.js 版本。例如，如果您使用的是 Node.js 16 平台分支，您只能指定 16.x.y Node.js 版本。您可以使用 npm 支援的版本範圍選項以允許更多的靈活性。關於每個平台分支的有效 Node.js 版本，請參閱 *AWS Elastic Beanstalk 平台指南*中的 [https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.nodejs)。

**注意**  
如果您所使用的 Node.js 版本的支援已從平台移除，您必須在[平台更新](using-features.platform.upgrade.md)之前變更或移除 Node.js 版本設定。當發現一個或多個版本的 Node.js 存在安全漏洞時，可能會出現此種狀況。  
此時，如果嘗試將不支援已設定 Node.js 版本的平台更新至新版本，此動作將會失敗。為省去建立新環境的必要，請將 `package.json` 中的 Node.js 版本設定變更為新舊平台版本皆支援的 Node.js 版本。您可以選擇指定包含支援版本的 Node.js 版本範圍，如本主題之前所述。您也可以選擇移除設定，然後部署新的來源套件。

# 在 Elastic Beanstalk npm shrinkwrap上使用 鎖定相依性
<a name="nodejs-platform-shrinkwrap"></a>

Node.js 平台會在您每次部署時以 *webapp* 使用者身分執行 `npm install`。當您的相依檔案存在可用的新版本時，則會在您部署應用程式時安裝這些版本，故可能造成部署作業需要長時間才能完成。

您可以藉由建立 `npm-shrinkwrap.json` 檔案，來將應用程式的相依檔案鎖定為目前的版本，以避免相依檔案的升級。

```
$ npm install
$ npm shrinkwrap
wrote npm-shrinkwrap.json
```

在您的原始碼套件中加入此檔案，以確保相依檔案只會安裝一次。

# 設定代理伺服器
<a name="nodejs-platform-proxy"></a>

Elastic Beanstalk 可以使用 NGINX 或 Apache HTTPD 做為反向代理伺服器，在連接埠 80 上將您的應用程式映射到 Elastic Load Balancing 負載平衡器。預設值為 NGINX。Elastic Beanstalk 提供了預設的代理組態，您可以加以擴展，或使用自己的組態將其完全覆寫。

Elastic Beanstalk 預設會設定代理將請求轉送至連接埠 5000 上的應用程式。您可將 `PORT` [環境屬性](create_deploy_nodejs.container.md#nodejs-platform-console)設定為主要應用程式接聽的連接埠，藉此覆寫預設連接埠。

**注意**  
您應用程式接聽的連接埠，不會影響 NGINX 伺服器為接收來自負載平衡器的請求所接聽的連接埠。

**在您的平台版本上設定代理伺服器**  
所有 AL2023/AL2 平台皆支援統一的代理組態功能。如需在執行 AL2023/AL2 的平台版本上設定代理伺服器的詳細資訊，請參閱 [反向代理組態](platforms-linux-extend.proxy.md)。

## 在 Amazon Linux AMI (之前的 Amazon Linux 2) 上設定代理
<a name="nodejs-platform-proxy.alami"></a>

如果您的 Elastic Beanstalk Node.js 環境使用 Amazon Linux AMI 平台版本 (先前的 Amazon Linux 2)，請閱讀本節中的資訊。

**備註**  
本主題中的資訊僅適用於以 Amazon Linux AMI (AL1) 為基礎的平台分支。AL2023/AL2 平台分支與舊版 Amazon Linux AMI (AL1) 平台版本不相容，*需要不同的組態設定*。
 在 [2022 年 7 月 18 日，](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html)Elastic Beanstalk 會根據 Amazon Linux AMI (AL1) 將所有平台分支的狀態設定為**已淘汰**。如需有關遷移至完全支援的目前 Amazon Linux 2023 平台分支的詳細資訊，請參閱 [將您的 Elastic Beanstalk Linux 應用程式遷移到 Amazon Linux 2023 或 Amazon Linux 2](using-features.migration-al.md)。

### 擴展和覆寫預設的代理組態 — Amazon Linux AMI (AL1)
<a name="nodejs-platform-proxy.alami.extending"></a>

Node.js 平台使用反向代理程式，將執行個體上來自 80 通訊埠的請求，轉傳給接聽 8081 埠的應用程式。Elastic Beanstalk 提供了預設的代理組態，您可以加以擴展，或使用自己的組態將其完全覆寫。

若要擴展預設的組態，請利用組態檔案，將 `.conf` 檔案加入至 `/etc/nginx/conf.d`。如需特定範例，請參閱 [在執行 Node.js 的 EC2 執行個體上終止 HTTPS](https-singleinstance-nodejs.md)。

Node.js 平台會將 PORT 環境變數設定為代理伺服器傳送流量至其中的連接埠。在您的程式碼中讀取此變數，以設定您應用程式的連接埠。

```
    var port = process.env.PORT || 3000;

    var server = app.listen(port, function () {
        console.log('Server running at http://127.0.0.1:' + port + '/');
    });
```

預設的 NGINX 組態會將流量轉發至位於 `127.0.0.1:8081`，名為 `nodejs` 的上游伺服器。您可以移除預設的組態，並在[組態檔案](ebextensions.md)中提供自己的組態。

**Example .ebextensions/proxy.config**  
下列的範例移除了預設的組態，並新增自訂組態，來將流量轉傳到 5,000 埠而非 8,081 埠。  

```
files:
  /etc/nginx/conf.d/proxy.conf:
    mode: "000644"
    owner: root
    group: root
    content: |
      upstream nodejs {
        server 127.0.0.1:5000;
        keepalive 256;
      }

      server {
        listen 8080;

        if ($time_iso8601 ~ "^(\d{4})-(\d{2})-(\d{2})T(\d{2})") {
            set $year $1;
            set $month $2;
            set $day $3;
            set $hour $4;
        }
        access_log /var/log/nginx/healthd/application.log.$year-$month-$day-$hour healthd;
        access_log  /var/log/nginx/access.log  main;

        location / {
            proxy_pass  http://nodejs;
            proxy_set_header   Connection "";
            proxy_http_version 1.1;
            proxy_set_header        Host            $host;
            proxy_set_header        X-Real-IP       $remote_addr;
            proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
        }

        gzip on;
        gzip_comp_level 4;
        gzip_types text/html text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;

        location /static {
            alias /var/app/current/static;
        }

      }

  /opt/elasticbeanstalk/hooks/configdeploy/post/99_kill_default_nginx.sh:
    mode: "000755"
    owner: root
    group: root
    content: |
      #!/bin/bash -xe
      rm -f /etc/nginx/conf.d/00_elastic_beanstalk_proxy.conf
      service nginx stop 
      service nginx start

container_commands:
  removeconfig:
    command: "rm -f /tmp/deployment/config/#etc#nginx#conf.d#00_elastic_beanstalk_proxy.conf /etc/nginx/conf.d/00_elastic_beanstalk_proxy.conf"
```
範例組態 (`/etc/nginx/conf.d/proxy.conf`) 使用了位於 `/etc/nginx/conf.d/00_elastic_beanstalk_proxy.conf` 的預設組態做為基礎，以納入預設的伺服器區塊，此區塊具備壓縮與日誌設定，和靜態檔案映射。  
`removeconfig` 命令會移除容器的預設組態，因此代理伺服器使用自訂組態。Elastic Beanstalk 會在部署每個組態時，重新建立預設組態。為了說明此點，在下列範例中，新增了 post-configuration-deployment hook (`/opt/elasticbeanstalk/hooks/configdeploy/post/99_kill_default_nginx.sh`)。這會移除預設配置，並重新啟動代理伺服器。

**注意**  
在 Node.js 平台的未來版本中，預設組態可能會變更。請使用最新版本的組態來做為您自訂項目的基礎，以確保相容性。

如果您覆寫預設組態，則必須定義所有靜態檔案映射和 GZIP 壓縮。這是因為平台無法套用[標準設定](create_deploy_nodejs.container.md#nodejs-namespaces)。

# 更多適用於 Node.js 的 Elastic Beanstalk 範例應用程式和教學課程
<a name="nodejs-getstarted"></a>

本節提供額外的應用程式和教學課程。先前在本[適用於 Node.js 的 QuickStart ](nodejs-quickstart.md)主題中的主題會逐步引導您使用 EB CLI 啟動範例 Node.js 應用程式。

 若要開始使用 Node.js 應用程式 AWS Elastic Beanstalk，您只需要上傳應用程式[原始碼套件](applications-sourcebundle.md)做為第一個應用程式版本，並部署到環境。

## 使用範例 Node.js 應用程式來啟動環境
<a name="nodejs-getstarted-samples"></a>

Elastic Beanstalk 為每個平台提供單頁範例應用程式，以及更複雜的範例，示範如何使用其他 AWS 資源，例如 Amazon RDS 和語言或平台特定的功能和 APIs。

**注意**  
請依照原始碼套件 `README.md` 檔案中的步驟進行部署。


**範例**  

|  環境類型  |  原始碼套件  |  Description  | 
| --- | --- | --- | 
|  Web 伺服器  |   [nodejs.zip](samples/nodejs.zip)   |  單頁應用程式。 若要使用 EB CLI 啟動範例應用程式，請參閱 [適用於 Node.js 的 QuickStart ](nodejs-quickstart.md)。 您也可以使用 Elastic Beanstalk 主控台來啟動範例應用程式。如需詳細步驟，請參閱本指南*入門*章節中的[建立範例應用程式](GettingStarted.md#GettingStarted.CreateApp)。  | 
|  具備 Amazon RDS 的 Web 伺服器  |  [nodejs-example-express-rds.zip](samples/nodejs-example-express-rds.zip)  |  使用 Express 架構和 Amazon Relational Database Service (RDS) 的健行日誌應用程式。 [教學課程](create_deploy_nodejs_express.md)  | 
|  具備 Amazon ElastiCache 的 Web 伺服器  |  [nodejs-example-express-elasticache.zip](samples/nodejs-example-express-elasticache.zip)  |  使用 Amazon ElastiCache 進行叢集功能的 Express Web 應用程式。叢集會提高您的 Web 應用程式的可用性、效能和安全性。 [教學課程](nodejs-express-clustering.md)  | 
|  具備 DynamoDB、Amazon SNS 和 Amazon SQS 的 Web 伺服器  |  [nodejs-example-dynamo.zip](samples/nodejs-example-dynamo.zip)  |  針對新公司行銷活動收集使用者聯絡資訊的 Express 網站。使用 Node.js 中適用於 JavaScript 的 AWS SDK 將項目寫入 DynamoDB 資料表，以及 Elastic Beanstalk 組態檔案，以在 DynamoDB、Amazon SNS 和 Amazon SQS 中建立資源。 [教學課程](nodejs-dynamodb-tutorial.md)  | 

## 後續步驟
<a name="nodejs-getstarted-next"></a>

在您擁有執行應用程式的環境後，可以隨時部署應用程式的新版本或完全不同的應用程式。部署新的應用程式版本非常快速，因無須佈建或重新啟動 EC2 執行個體。如需應用程式部署的詳細資訊，請參閱[部署應用程式的新版本](GettingStarted.md#GettingStarted.DeployApp)。

部署範例應用程式或兩個應用程式，並準備好在本機開始開發和執行 Node.js 應用程式後，請參閱 [設定 Elastic Beanstalk 的 Node.js 開發環境](nodejs-devenv.md) ，以使用您需要的所有工具設定 Node.js 開發環境。

# 將 Node.js Express 應用程式部署至 Elastic Beanstalk
<a name="create_deploy_nodejs_express"></a>

本節將逐步引導您使用 Elastic Beanstalk 命令列界面 (EB CLI) 將範例應用程式部署至 Elastic Beanstalk，然後更新應用程式以使用 [Express](http://expressjs.com/) 架構。

## 先決條件
<a name="create_deploy_nodejs_express.prerequisites"></a>

本教學課程需要下列先決條件：
+ Node.js 執行階段
+ 預設的 Node.js 套件管理工具軟體 npm
+ Express 命令列產生器
+ Elastic Beanstalk 命令列界面 (EB CLI)

有關安裝所列出之前三個元件和設定本機開發環境的詳細資訊，請參閱 [設定 Elastic Beanstalk 的 Node.js 開發環境](nodejs-devenv.md)。在本教學課程中，您不需要安裝適用於 Node.js 的 AWS SDK，這也在參考主題中提及。

有關安裝和設定 EB CLI 的詳細資訊，請參閱 [使用設定指令碼安裝 EB CLI （建議）](eb-cli3.md#eb-cli3-install) 和 [設定 EB CLI](eb-cli3-configuration.md)。

## 建立 Elastic Beanstalk 環境
<a name="create_deploy_nodejs_express.eb_init-rds"></a>

**應用程式目錄**  
對於應用程式原始碼套件，本教學課程使用的是名為 `nodejs-example-express-rds` 的目錄。為本教學課程建立 `nodejs-example-express-rds` 目錄。

```
~$ mkdir nodejs-example-express-rds
```

**注意**  
本章中的每個教學課程皆會使用其自身的應用程式原始碼套件目錄。目錄名稱與教學課程所使用的範例應用程式名稱相符。

將您目前的工作目錄變更為 `nodejs-example-express-rds`。

```
~$ cd nodejs-example-express-rds
```

現在，來設定執行 Node.js 平台和範例應用程式的 Elastic Beanstalk 環境。我們將會使用 Elastic Beanstalk 命令列介面 (EB CLI)。

**設定應用程式的 EB CLI 儲存庫，並建立執行 Node.js 平台的 Elastic Beanstalk 環境**

1. 使用 **[**eb init**](eb3-init.md)** 命令建立一個儲存庫。

   ```
   ~/nodejs-example-express-rds$ eb init --platform node.js --region <region>
   ```

   此命令會在名為 `.elasticbeanstalk` 的資料夾內建立組態檔案，其中會指定應用程式使用的環境設定，並以目前資料夾為名建立 Elastic Beanstalk 應用程式。

1. 使用 **[**eb create**](eb3-create.md)** 命令建立執行範例應用程式的環境。

   ```
   ~/nodejs-example-express-rds$ eb create --sample nodejs-example-express-rds
   ```

   本命令會使用 Node.js 平台的預設設定和下列資源，建立負載平衡的環境：
   + **EC2 執行個體** ‒ Amazon Elastic Compute Cloud (Amazon EC2) 虛擬機器，已設為在您選擇的平台上執行 Web 應用程式。

     每個平台會執行特定的一套軟體、設定檔和指令碼，來支援特定的語言版本、架構、Web 容器或其組合。大多數的平台使用會 Apache 或 NGINX 做為反向代理，此反向代理會在您 Web 應用程式的前景執行、轉傳遞交給此 Web 應用程式的請求、提供靜態資產，並產生存取和錯誤日誌。
   + **執行個體安全群組** - Amazon EC2 安全群組，已設為允許從連接埠 80 傳入的流量。此資源可讓負載平衡器傳來的 HTTP 傳輸資料，到達執行您 Web 應用程式的 EC2 執行個體。在預設情況下，不允許傳輸資料從其他通訊埠傳送。
   + **負載平衡器** - Elastic Load Balancing 負載平衡器，可設定將請求分配到執行您應用程式的執行個體。負載平衡器也讓您的執行個體不需直接連接到網際網路。
   + **負載平衡器安全群組** - Amazon EC2 安全群組，設為允許從連接埠 80 傳入的流量。此資源可讓來自網際網路的 HTTP 傳輸資料到達負載平衡器。在預設情況下，不允許傳輸資料從其他通訊埠傳送。
   + **Auto Scaling 群組** - Auto Scaling 群組，設為在執行個體終止或無法使用時，取代該執行個體。
   + **Amazon S3 儲存貯體** - 儲存位置，用來儲存當您使用 Elastic Beanstalk 時所建立的原始程式碼、日誌和其他成品。
   + **Amazon CloudWatch 警示** - 兩種 CloudWatch 警示，用來監控您環境中執行個體上的負載，會在負載過高或過低時觸發。當警示觸發時，您的 Auto Scaling 群組會擴展或縮減以進行回應。
   + **CloudFormation 堆疊** – Elastic Beanstalk 使用 CloudFormation 啟動環境中的資源並傳播組態變更。資源定義於範本中，您可在 [CloudFormation 主控台](https://console.aws.amazon.com/cloudformation)中檢視此範本。
   + **網域名稱** – 會路由到您 Web 應用程式的網域名稱，其格式為 **subdomain*.*region*.elasticbeanstalk.com*。
**網域安全**  
為了增強 Elastic Beanstalk 應用程式的安全性，我們會在[公共后缀列表 (PSL)](https://publicsuffix.org/) 中註冊網域 *elasticbeanstalk.com*。  
如果您需要在 Elastic Beanstalk 應用程式的預設網域名稱中設定敏感 Cookie，建議您使用字`__Host-`首為 的 Cookie 以提高安全性。此實務可保護您的網域免於跨網站請求偽造嘗試 (CSRF)。如需更多資訊，請參閱 Mozilla 開發人員網路中的[設定 Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes) 頁面。

1. 環境建立完成後，請使用 [**eb open**](eb3-open.md) 命令，在預設瀏覽器中開啟環境 URL。

   ```
   ~/nodejs-example-express-rds$ eb open
   ```

您現在已使用範例應用程式建立 Node.js Elastic Beanstalk 環境。您可以使用自己的應用程式對其進行更新。接下來，我們會更新範例應用程式，以使用 Express 架構。

## 更新應用程式以使用 Express
<a name="create_deploy_nodejs_express.update"></a>

使用範例應用程式建立環境後，您可使用自己的應用程式對其進行更新。在此程序中，我們先執行 **express** 和 **npm install** 命令，以便在應用程式目錄中設定 Express 架構。然後，我們將使用 EB CLI，以便使用已更新的應用程式來更新您的 Elastic Beanstalk 環境。

**欲更新您的應用程式以使用 Express**

1. 執行 `express` 命令。這會產生 `package.json`、`app.js` 以及幾個目錄。

   ```
   ~/nodejs-example-express-rds$ express
   ```

   當提示您是否要繼續時，請輸入 **y**。
**注意**  
如果 **express** 命令無法使用，您可能未依先前*先決條件*章節中的所述內容安裝 Express 命令列產生器。或者，您可能需要設定本機電腦的目錄路徑設定，才可執行 **express** 命令。如需有關設定開發環境的詳細步驟，請參閱*先決條件*章節，以繼續進行本教學課程。

1. 設定本機依存項目。

   ```
   ~/nodejs-example-express-rds$ npm install
   ```

1. (選用) 確認 Web 應用程式伺服器已啟動。

   ```
   ~/nodejs-example-express-rds$ npm start
   ```

   您應該會看到類似下列的輸出：

   ```
   > nodejs@0.0.0 start /home/local/user/node-express
   > node ./bin/www
   ```

   依預設，伺服器將會在連接埠 3000 上執行。若要進行測試，請在另一部終端機上執行 `curl http://localhost:3000`，或在本機電腦開啟瀏覽器並輸入 URL 位址 `http://localhost:3000`。

   按 **Ctrl\$1C** 來停止伺服器。

1. 使用 [**eb deploy**](eb3-deploy.md) 命令將變更部署至您的 Elastic Beanstalk 環境。

   ```
   ~/nodejs-example-express-rds$ eb deploy
   ```

1. 一旦環境為綠色且就緒，請重新整理 URL，確認其正常運作。您應看到顯示 **Welcome to Express** 的網頁。

接著，我們會更新 Express 應用程式以提供靜態檔案，並新增新的頁面。

**欲設定靜態檔案並新增新的頁面至您的 Express 應用程式**

1. 使用下列內容，在 [`.ebextensions`](ebextensions.md) 資料夾中新增第二個組態檔案：

   **`nodejs-example-express-rds/.ebextensions/staticfiles.config`**

   ```
   option_settings:
       aws:elasticbeanstalk:environment:proxy:staticfiles:
           /stylesheets: public/stylesheets
   ```

   此設定會將代理伺服器設定為在應用程式 `public` 路徑的 `/public` 資料夾內提供檔案。從代理伺服器靜態提供檔案，能夠減少應用程式負載。如需詳細資訊，請參閱本章先前所述的[靜態檔案](create_deploy_nodejs.container.md#nodejs-platform-console-staticfiles)。

1. (選用) 若要確認靜態映射的設定是否正確，請在 `nodejs-example-express-rds/app.js` 中註解靜態映射設定。這會從節點應用程式中移除映射。

   ```
   //  app.use(express.static(path.join(__dirname, 'public'))); 
   ```

   即使在註解此行後，上一個步驟 `staticfiles.config` 檔案中的靜態檔案映射應仍可成功載入樣式表。若要確認靜態檔案映射是透過代理靜態檔案組態 (而非 Express 應用程式) 載入，請移除 `option_settings:` 後的值。將其從靜態檔案組態和節點應用程式移除之後，樣式表將無法載入。

   完成測試時，請記得重設 `nodejs-example-express-rds/app.js` 及 `staticfiles.config` 的內容。

1. 新增 `nodejs-example-express-rds/routes/hike.js`。輸入下列內容：

   ```
   exports.index = function(req, res) {
    res.render('hike', {title: 'My Hiking Log'});
   };
   
   exports.add_hike = function(req, res) {
   };
   ```

1. 更新 `nodejs-example-express-rds/app.js` 以納入三個新的行。

   首先，新增下列行來為此路由添加 `require`：

   ```
   var hike = require('./routes/hike');
   ```

   您的檔案看起來如下列程式碼片段：

   ```
   var express = require('express');
   var path = require('path');
   var hike = require('./routes/hike');
   ```

   然後，請在 `nodejs-example-express-rds/app.js` 後將下列兩行新增至 `var app = express();`：

   ```
   app.get('/hikes', hike.index);
   app.post('/add_hike', hike.add_hike);
   ```

   您的檔案看起來如下列程式碼片段：

   ```
   var app = express();
   app.get('/hikes', hike.index);
   app.post('/add_hike', hike.add_hike);
   ```

1. 將 `nodejs-example-express-rds/views/index.jade` 複製至 `nodejs-example-express-rds/views/hike.jade`。

   ```
   ~/nodejs-example-express-rds$ cp views/index.jade views/hike.jade
   ```

1. 使用 [**eb deploy**](eb3-deploy.md) 命令部署變更。

   ```
   ~/nodejs-example-express-rds$ eb deploy
   ```

1. 您的環境將在幾分鐘後更新。您的環境為綠色且就緒後，請重新整理您的瀏覽器，並將 **hikes** 附加至 URL 尾端 (即 `http://node-express-env-syypntcz2q.elasticbeanstalk.com/hikes`)，藉此確認其正常運作。

   您應看到標題為 **My Hiking Log (My Hiking Log)** 的網頁。

現在，您已建立使用 Express 架構的 Web 應用程式。在下一節中，我們將修改應用程式，以使用 Amazon Relational Database Service (RDS) 儲存健行日誌。

## 更新應用程式，以使用 Amazon RDS
<a name="create_deploy_nodejs_express.add_rds"></a>

在下一個步驟中，我們將更新應用程式，以使用 Amazon RDS for MySQL。

**更新應用程式，以使用 RDS for MySQL**

1. 若要建立與 Elastic Beanstalk 環境耦合的 RDS for MySQL 資料庫，請遵循本章後續[新增資料庫](create-deploy-nodejs.rds.md)主題中的指示。新增資料庫執行個體約需要 10 分鐘。

1.  使用下列內容更新 `package.json` 中的相依性區段：

   ```
   "dependencies": {
       "async": "^3.2.4",
       "express": "4.18.2",
       "jade": "1.11.0",
       "mysql": "2.18.1",
       "node-uuid": "^1.4.8",
       "body-parser": "^1.20.1",
       "method-override": "^3.0.0",
       "morgan": "^1.10.0",
       "errorhandler": "^1.5.1"
     }
   ```

1. 執行 **npm install**。

   ```
   ~/nodejs-example-express-rds$ npm install
   ```

1. 更新 `app.js`，以便連接至資料庫、建立資料表，並插入單一預設增長日誌。每次部署此應用程式時，其會捨棄先前的增長資料表，並重新建立。

   ```
   /**
    * Module dependencies.
    */
   
    const express = require('express')
    , routes = require('./routes')
    , hike = require('./routes/hike')
    , http = require('http')
    , path = require('path')
    , mysql = require('mysql')
    , async = require('async')
    , bodyParser = require('body-parser')
    , methodOverride = require('method-override')
    , morgan = require('morgan')
    , errorhandler = require('errorhandler');
   
   const { connect } = require('http2');
   
   const app = express()
   
   app.set('views', __dirname + '/views')
   app.set('view engine', 'jade')
   app.use(methodOverride())
   app.use(bodyParser.json())
   app.use(bodyParser.urlencoded({ extended: true }))
   app.use(express.static(path.join(__dirname, 'public')))
   
   
   app.set('connection', mysql.createConnection({
   host: process.env.RDS_HOSTNAME,
   user: process.env.RDS_USERNAME,
   password: process.env.RDS_PASSWORD,
   port: process.env.RDS_PORT}));  
   
   function init() {
    app.get('/', routes.index);
    app.get('/hikes', hike.index);
    app.post('/add_hike', hike.add_hike);
   }
   
   const client = app.get('connection');
   async.series([
    function connect(callback) {
      client.connect(callback);
      console.log('Connected!');
    },
    function clear(callback) {
      client.query('DROP DATABASE IF EXISTS mynode_db', callback);
    },
    function create_db(callback) {
      client.query('CREATE DATABASE mynode_db', callback);
    },
    function use_db(callback) {
      client.query('USE mynode_db', callback);
    },
    function create_table(callback) {
       client.query('CREATE TABLE HIKES (' +
                           'ID VARCHAR(40), ' +
                           'HIKE_DATE DATE, ' +
                           'NAME VARCHAR(40), ' +
                           'DISTANCE VARCHAR(40), ' +
                           'LOCATION VARCHAR(40), ' +
                           'WEATHER VARCHAR(40), ' +
                           'PRIMARY KEY(ID))', callback);
    },
    function insert_default(callback) {
      const hike = {HIKE_DATE: new Date(), NAME: 'Hazard Stevens',
            LOCATION: 'Mt Rainier', DISTANCE: '4,027m vertical', WEATHER:'Bad', ID: '12345'};
      client.query('INSERT INTO HIKES set ?', hike, callback);
    }
   ], function (err, results) {
    if (err) {
      console.log('Exception initializing database.');
      throw err;
    } else {
      console.log('Database initialization complete.');
      init();
    }
   });
   
   module.exports = app
   ```

1. 將下列內容新增至 `routes/hike.js`。這將使路線能夠將新的增長日誌插入*增長*資料庫。

   ```
   const uuid = require('node-uuid');
   exports.index = function(req, res) {
     res.app.get('connection').query( 'SELECT * FROM HIKES', function(err,
   rows) {
       if (err) {
         res.send(err);
       } else {
         console.log(JSON.stringify(rows));
         res.render('hike', {title: 'My Hiking Log', hikes: rows});
     }});
   };
   exports.add_hike = function(req, res){
     const input = req.body.hike;
     const hike = { HIKE_DATE: new Date(), ID: uuid.v4(), NAME: input.NAME,
     LOCATION: input.LOCATION, DISTANCE: input.DISTANCE, WEATHER: input.WEATHER};
     console.log('Request to log hike:' + JSON.stringify(hike));
     req.app.get('connection').query('INSERT INTO HIKES set ?', hike, function(err) {
         if (err) {
           res.send(err);
         } else {
           res.redirect('/hikes');
         }
      });
   };
   ```

1. 將 `routes/index.js` 的內容取代為：

   ```
   /*
    * GET home page.
    */
   
   exports.index = function(req, res){
     res.render('index', { title: 'Express' });
   };
   ```

1. 將以下 Jade 範本新增至 `views/hike.jade`，以提供用於新增增長日誌的使用者介面。

   ```
   extends layout
   
   block content
     h1= title
     p Welcome to #{title}
   
     form(action="/add_hike", method="post")
       table(border="1")
         tr
           td Your Name
           td
             input(name="hike[NAME]", type="textbox")
         tr
           td Location
           td
             input(name="hike[LOCATION]", type="textbox")
         tr
           td Distance
           td
             input(name="hike[DISTANCE]", type="textbox")
         tr
           td Weather
           td
             input(name="hike[WEATHER]", type="radio", value="Good")
             | Good
             input(name="hike[WEATHER]", type="radio", value="Bad")
             | Bad
             input(name="hike[WEATHER]", type="radio", value="Seattle", checked)
             | Seattle
         tr
           td(colspan="2")
             input(type="submit", value="Record Hike")
   
     div
       h3 Hikes
       table(border="1")
         tr
           td Date
           td Name
           td Location
           td Distance
           td Weather
         each hike in hikes
           tr
             td #{hike.HIKE_DATE.toDateString()}
             td #{hike.NAME}
             td #{hike.LOCATION}
             td #{hike.DISTANCE}
             td #{hike.WEATHER}
   ```

1. 使用 [**eb deploy**](eb3-deploy.md) 命令部署變更。

   ```
   ~/nodejs-example-express-rds$ eb deploy
   ```

## 清除
<a name="create_deploy_nodejs_express.delete"></a>

如果您已完成使用 Elastic Beanstalk，您可終止環境。

使用 **eb terminate** 命令來終止您的環境及其中的所有資源。

```
~/nodejs-example-express-rds$ eb terminate
The environment "nodejs-example-express-rds-env" and all associated instances will be terminated.
To confirm, type the environment name: nodejs-example-express-rds-env
INFO: terminateEnvironment is starting.
...
```

# 使用叢集將 Node.js Express 應用程式部署至 Elastic Beanstalk
<a name="nodejs-express-clustering"></a>

本教學課程會逐步解說如何使用 Elastic Beanstalk 命令列界面 (EB CLI)，將範例應用程式部署至 Elastic Beanstalk，並解釋如何更新應用程式，以使用 [Express](http://expressjs.com/) 框架、[Amazon ElastiCache](https://aws.amazon.com/elasticache/) 和叢集功能。叢集會提高您的 Web 應用程式的可用性、效能和安全性。若要進一步了解 Amazon ElastiCache，請前往《[Amazon ElastiCache (Memcached) 使用者指南》中的什麼是 Amazon ElastiCache (Memcached)？](https://docs.aws.amazon.com/AmazonElastiCache/latest/mem-ug/Introduction.html)。 *Amazon ElastiCache *

**注意**  
此範例會建立您可能需要付費 AWS 的資源。如需 AWS 定價的詳細資訊，請參閱 [https://aws.amazon.com/pricing/](https://aws.amazon.com/pricing/)。有些服務是 AWS 免費用量方案的一部分。若您是新客戶，可以免費試用這些服務。如需詳細資訊，請參閱[https://aws.amazon.com/free/](https://aws.amazon.com/free/)。

## 先決條件
<a name="nodejs-express-clustering.prereq"></a>

本教學課程需要下列先決條件：
+ Node.js 執行階段
+ 預設的 Node.js 套件管理工具軟體 npm
+ Express 命令列產生器
+ Elastic Beanstalk 命令列界面 (EB CLI)

有關安裝所列出之前三個元件和設定本機開發環境的詳細資訊，請參閱 [設定 Elastic Beanstalk 的 Node.js 開發環境](nodejs-devenv.md)。在本教學課程中，您不需要安裝適用於 Node.js 的 AWS SDK，這也在參考主題中提及。

有關安裝和設定 EB CLI 的詳細資訊，請參閱 [使用設定指令碼安裝 EB CLI （建議）](eb-cli3.md#eb-cli3-install) 和 [設定 EB CLI](eb-cli3-configuration.md)。

## 建立 Elastic Beanstalk 環境
<a name="nodejs-express-clustering.create"></a>

**應用程式目錄**  
對於應用程式原始碼套件，本教學課程使用的是名為 `nodejs-example-express-elasticache` 的目錄。為本教學課程建立 `nodejs-example-express-elasticache` 目錄。

```
~$ mkdir nodejs-example-express-elasticache
```

**注意**  
本章中的每個教學課程皆會使用其自身的應用程式原始碼套件目錄。目錄名稱與教學課程所使用的範例應用程式名稱相符。

將您目前的工作目錄變更為 `nodejs-example-express-elasticache`。

```
~$ cd nodejs-example-express-elasticache
```

現在，來設定執行 Node.js 平台和範例應用程式的 Elastic Beanstalk 環境。我們將會使用 Elastic Beanstalk 命令列介面 (EB CLI)。

**設定應用程式的 EB CLI 儲存庫，並建立執行 Node.js 平台的 Elastic Beanstalk 環境**

1. 使用 **[**eb init**](eb3-init.md)** 命令建立一個儲存庫。

   ```
   ~/nodejs-example-express-elasticache$ eb init --platform node.js --region <region>
   ```

   此命令會在名為 `.elasticbeanstalk` 的資料夾內建立組態檔案，其中會指定應用程式使用的環境設定，並以目前資料夾為名建立 Elastic Beanstalk 應用程式。

1. 使用 **[**eb create**](eb3-create.md)** 命令建立執行範例應用程式的環境。

   ```
   ~/nodejs-example-express-elasticache$ eb create --sample nodejs-example-express-elasticache
   ```

   本命令會使用 Node.js 平台的預設設定和下列資源，建立負載平衡的環境：
   + **EC2 執行個體** ‒ Amazon Elastic Compute Cloud (Amazon EC2) 虛擬機器，已設為在您選擇的平台上執行 Web 應用程式。

     每個平台會執行特定的一套軟體、設定檔和指令碼，來支援特定的語言版本、架構、Web 容器或其組合。大多數的平台使用會 Apache 或 NGINX 做為反向代理，此反向代理會在您 Web 應用程式的前景執行、轉傳遞交給此 Web 應用程式的請求、提供靜態資產，並產生存取和錯誤日誌。
   + **執行個體安全群組** - Amazon EC2 安全群組，已設為允許從連接埠 80 傳入的流量。此資源可讓負載平衡器傳來的 HTTP 傳輸資料，到達執行您 Web 應用程式的 EC2 執行個體。在預設情況下，不允許傳輸資料從其他通訊埠傳送。
   + **負載平衡器** - Elastic Load Balancing 負載平衡器，可設定將請求分配到執行您應用程式的執行個體。負載平衡器也讓您的執行個體不需直接連接到網際網路。
   + **負載平衡器安全群組** - Amazon EC2 安全群組，設為允許從連接埠 80 傳入的流量。此資源可讓來自網際網路的 HTTP 傳輸資料到達負載平衡器。在預設情況下，不允許傳輸資料從其他通訊埠傳送。
   + **Auto Scaling 群組** - Auto Scaling 群組，設為在執行個體終止或無法使用時，取代該執行個體。
   + **Amazon S3 儲存貯體** - 儲存位置，用來儲存當您使用 Elastic Beanstalk 時所建立的原始程式碼、日誌和其他成品。
   + **Amazon CloudWatch 警示** - 兩種 CloudWatch 警示，用來監控您環境中執行個體上的負載，會在負載過高或過低時觸發。當警示觸發時，您的 Auto Scaling 群組會擴展或縮減以進行回應。
   + **CloudFormation 堆疊** – Elastic Beanstalk 使用 CloudFormation 啟動環境中的資源並傳播組態變更。資源定義於範本中，您可在 [CloudFormation 主控台](https://console.aws.amazon.com/cloudformation)中檢視此範本。
   + **網域名稱** – 會路由到您 Web 應用程式的網域名稱，其格式為 **subdomain*.*region*.elasticbeanstalk.com*。
**網域安全**  
為了增強 Elastic Beanstalk 應用程式的安全性，我們會在[公共后缀列表 (PSL)](https://publicsuffix.org/) 中註冊網域 *elasticbeanstalk.com*。  
如果您需要在 Elastic Beanstalk 應用程式的預設網域名稱中設定敏感 Cookie，建議您使用字`__Host-`首為 的 Cookie 以提高安全性。此實務可保護您的網域免於跨網站請求偽造嘗試 (CSRF)。如需更多資訊，請參閱 Mozilla 開發人員網路中的[設定 Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes) 頁面。

1. 環境建立完成後，請使用 [**eb open**](eb3-open.md) 命令，在預設瀏覽器中開啟環境 URL。

   ```
   ~/nodejs-example-express-elasticache$ eb open
   ```

您現在已使用範例應用程式建立 Node.js Elastic Beanstalk 環境。您可以使用自己的應用程式對其進行更新。接下來，我們會更新範例應用程式，以使用 Express 架構。

## 更新應用程式以使用 Express
<a name="nodejs-express-clustering.update"></a>

更新 Elastic Beanstalk 環境中的範例應用程式，以使用 Express 框架。

您可以從 [nodejs-example-express-elasticache.zip](samples/nodejs-example-express-elasticache.zip) 下載最終原始碼。

**欲更新您的應用程式以使用 Express**

使用範例應用程式建立環境後，您可使用自己的應用程式對其進行更新。在此程序中，我們先執行 **express** 和 **npm install** 命令，以便在應用程式目錄中設定 Express 架構。

1. 執行 `express` 命令。這會產生 `package.json`、`app.js` 以及幾個目錄。

   ```
   ~/nodejs-example-express-elasticache$ express
   ```

   當提示您是否要繼續時，請輸入 **y**。
**注意**  
如果 **express** 命令無法使用，您可能未依先前*先決條件*章節中的所述內容安裝 Express 命令列產生器。或者，您可能需要設定本機電腦的目錄路徑設定，才可執行 **express** 命令。如需有關設定開發環境的詳細步驟，請參閱*先決條件*章節，以繼續進行本教學課程。

1. 設定本機依存項目。

   ```
   ~/nodejs-example-express-elasticache$ npm install
   ```

1. (選用) 確認 Web 應用程式伺服器已啟動。

   ```
   ~/nodejs-example-express-elasticache$ npm start
   ```

   您應該會看到類似下列的輸出：

   ```
   > nodejs@0.0.0 start /home/local/user/node-express
   > node ./bin/www
   ```

   依預設，伺服器將會在連接埠 3000 上執行。若要進行測試，請在另一部終端機上執行 `curl http://localhost:3000`，或在本機電腦開啟瀏覽器並輸入 URL 位址 `http://localhost:3000`。

   按 **Ctrl\$1C** 來停止伺服器。

1. 重新命名 `nodejs-example-express-elasticache/app.js` 為 `nodejs-example-express-elasticache/express-app.js`。

   ```
   ~/nodejs-example-express-elasticache$ mv app.js express-app.js
   ```

1. 將 `nodejs-example-express-elasticache/express-app.js` 中的 `var app = express();` 列更新為以下內容：

   ```
   var app = module.exports = express();
   ```

1. 在您的本機電腦上，以下列程式碼建立名為 `nodejs-example-express-elasticache/app.js` 的檔案。

   ```
   /**
    * Module dependencies.
    */
   
    const express = require('express'),
    session = require('express-session'),
    bodyParser = require('body-parser'),
    methodOverride = require('method-override'),
    cookieParser = require('cookie-parser'),
    fs = require('fs'),
    filename = '/var/nodelist',
    app = express();
   
   let MemcachedStore = require('connect-memcached')(session);
   
   function setup(cacheNodes) {
    app.use(bodyParser.raw());
    app.use(methodOverride());
    if (cacheNodes.length > 0) {
      app.use(cookieParser());
   
      console.log('Using memcached store nodes:');
      console.log(cacheNodes);
   
      app.use(session({
        secret: 'your secret here',
        resave: false,
        saveUninitialized: false,
        store: new MemcachedStore({ 'hosts': cacheNodes })
      }));
    } else {
      console.log('Not using memcached store.');
      app.use(session({
        resave: false,
        saveUninitialized: false, secret: 'your secret here'
      }));
    }
   
    app.get('/', function (req, resp) {
      if (req.session.views) {
        req.session.views++
        resp.setHeader('Content-Type', 'text/html')
        resp.send(`You are session: ${req.session.id}. Views: ${req.session.views}`)
      } else {
        req.session.views = 1
        resp.send(`You are session: ${req.session.id}. No views yet, refresh the page!`)
      }
    });
   
    if (!module.parent) {
      console.log('Running express without cluster. Listening on port %d', process.env.PORT || 5000)
      app.listen(process.env.PORT || 5000)
    }
   }
   
   console.log("Reading elastic cache configuration")
   // Load elasticache configuration.
   fs.readFile(filename, 'UTF8', function (err, data) {
    if (err) throw err;
   
    let cacheNodes = []
    if (data) {
      let lines = data.split('\n');
      for (let i = 0; i < lines.length; i++) {
        if (lines[i].length > 0) {
          cacheNodes.push(lines[i])
        }
      }
    }
   
    setup(cacheNodes)
   });
   
   module.exports = app;
   ```

1. 將 `nodejs-example-express-elasticache/bin/www` 檔案的內容取代為下列內容：

   ```
   #!/usr/bin/env node
   
   /**
    * Module dependencies.
    */
   
   const app = require('../app');
   const cluster = require('cluster');
   const debug = require('debug')('nodejs-example-express-elasticache:server');
   const http = require('http');
   const workers = {},
     count = require('os').cpus().length;
   
   function spawn() {
     const worker = cluster.fork();
     workers[worker.pid] = worker;
     return worker;
   }
   
   
   /**
    * Get port from environment and store in Express.
    */
   
   const port = normalizePort(process.env.PORT || '3000');
   app.set('port', port);
   
   if (cluster.isMaster) {
     for (let i = 0; i < count; i++) {
       spawn();
     }
   
     // If a worker dies, log it to the console and start another worker.
     cluster.on('exit', function (worker, code, signal) {
       console.log('Worker ' + worker.process.pid + ' died.');
       cluster.fork();
     });
   
     // Log when a worker starts listening
     cluster.on('listening', function (worker, address) {
       console.log('Worker started with PID ' + worker.process.pid + '.');
     });
   
   } else {
     /**
      * Create HTTP server.
      */
   
     let server = http.createServer(app);
   
     /**
      * Event listener for HTTP server "error" event.
      */
   
     function onError(error) {
       if (error.syscall !== 'listen') {
         throw error;
       }
   
       const bind = typeof port === 'string'
         ? 'Pipe ' + port
         : 'Port ' + port;
   
       // handle specific listen errors with friendly messages
       switch (error.code) {
         case 'EACCES':
           console.error(bind + ' requires elevated privileges');
           process.exit(1);
           break;
         case 'EADDRINUSE':
           console.error(bind + ' is already in use');
           process.exit(1);
           break;
         default:
           throw error;
       }
     }
   
     /**
      * Event listener for HTTP server "listening" event.
      */
   
     function onListening() {
       const addr = server.address();
       const bind = typeof addr === 'string'
         ? 'pipe ' + addr
         : 'port ' + addr.port;
       debug('Listening on ' + bind);
     }
   
     /**
      * Listen on provided port, on all network interfaces.
      */
   
     server.listen(port);
     server.on('error', onError);
     server.on('listening', onListening);
   }
   
   /**
    * Normalize a port into a number, string, or false.
    */
   
   function normalizePort(val) {
     const port = parseInt(val, 10);
   
     if (isNaN(port)) {
       // named pipe
       return val;
     }
   
     if (port >= 0) {
       // port number
       return port;
     }
   
     return false;
   }
   ```

1. 使用 [**eb deploy**](eb3-deploy.md) 命令將變更部署至您的 Elastic Beanstalk 環境。

   ```
   ~/nodejs-example-express-elasticache$ eb deploy
   ```

1. 您的環境將在幾分鐘後更新。一旦環境為綠色且就緒，請重新整理 URL，確認其正常運作。您應看到顯示「Welcome to Express」的網頁。

您可以存取執行應用程式之 EC2 執行個體的日誌。如需存取日誌的說明，請參閱 [在 Elastic Beanstalk 環境中檢視 Amazon EC2 執行個體的日誌](using-features.logging.md)。

接著，我們將更新 Express 應用程式以使用 Amazon ElastiCache。

**更新您的 Express 應用程式以使用 Amazon ElastiCache**

1. 在您本機電腦原始碼套件的最上層目錄建立 `.ebextensions` 目錄。在此範例中，我們使用 `nodejs-example-express-elasticache/.ebextensions`.

1. 使用以下程式碼片段建立組態檔案 `nodejs-example-express-elasticache/.ebextensions/elasticache-iam-with-script.config`。如需組態檔案的詳細資訊，請參閱 [Node.js 組態命名空間](create_deploy_nodejs.container.md#nodejs-namespaces)。這會建立具有所需許可的 IAM 使用者，以探索 elasticache 節點並在快取變更時隨時進行寫入至檔案。您也可以從 [nodejs-example-express-elasticache.zip](samples/nodejs-example-express-elasticache.zip) 複製檔案。如需 ElastiCache 屬性的詳細資訊，請參閱 [範例：ElastiCache](customize-environment-resources-elasticache.md)。
**注意**  
YAML 憑藉一致的縮排。請在取代範例組態檔中的內容時，讓縮排層級一致，並確認您的文字編輯器使用空格而非定位字元進行縮排。

   ```
   Resources:
     MyCacheSecurityGroup:
       Type: 'AWS::EC2::SecurityGroup'
       Properties:
         GroupDescription: "Lock cache down to webserver access only"
         SecurityGroupIngress:
           - IpProtocol: tcp
             FromPort:
               Fn::GetOptionSetting:
                 OptionName: CachePort
                 DefaultValue: 11211
             ToPort:
               Fn::GetOptionSetting:
                 OptionName: CachePort
                 DefaultValue: 11211
             SourceSecurityGroupName:
               Ref: AWSEBSecurityGroup
     MyElastiCache:
       Type: 'AWS::ElastiCache::CacheCluster'
       Properties:
         CacheNodeType:
           Fn::GetOptionSetting:
             OptionName: CacheNodeType
             DefaultValue: cache.t2.micro
         NumCacheNodes:
           Fn::GetOptionSetting:
             OptionName: NumCacheNodes
             DefaultValue: 1
         Engine:
           Fn::GetOptionSetting:
             OptionName: Engine
             DefaultValue: redis
         VpcSecurityGroupIds:
           -
             Fn::GetAtt:
               - MyCacheSecurityGroup
               - GroupId
     AWSEBAutoScalingGroup :
       Metadata :
         ElastiCacheConfig :
           CacheName :
             Ref : MyElastiCache
           CacheSize :
              Fn::GetOptionSetting:
                OptionName : NumCacheNodes
                DefaultValue: 1
     WebServerUser : 
       Type : AWS::IAM::User
       Properties :
         Path : "/"
         Policies:
           -
             PolicyName: root
             PolicyDocument :
               Statement :
                 -
                   Effect : Allow
                   Action : 
                     - cloudformation:DescribeStackResource
                     - cloudformation:ListStackResources
                     - elasticache:DescribeCacheClusters
                   Resource : "*"
     WebServerKeys :
       Type : AWS::IAM::AccessKey
       Properties :
         UserName :
           Ref: WebServerUser
   
   Outputs:
     WebsiteURL:
       Description: sample output only here to show inline string function parsing
       Value: |
         http://`{ "Fn::GetAtt" : [ "AWSEBLoadBalancer", "DNSName" ] }`
     MyElastiCacheName:
       Description: Name of the elasticache
       Value:
         Ref : MyElastiCache
     NumCacheNodes:
       Description: Number of cache nodes in MyElastiCache
       Value:
         Fn::GetOptionSetting:
           OptionName : NumCacheNodes
           DefaultValue: 1
   
   files:
     "/etc/cfn/cfn-credentials" :
       content : |
         AWSAccessKeyId=`{ "Ref" : "WebServerKeys" }`
         AWSSecretKey=`{ "Fn::GetAtt" : ["WebServerKeys", "SecretAccessKey"] }`
       mode : "000400"
       owner : root
       group : root
   
     "/etc/cfn/get-cache-nodes" :
       content : |
         # Define environment variables for command line tools
         export AWS_ELASTICACHE_HOME="/home/ec2-user/elasticache/$(ls /home/ec2-user/elasticache/)"
         export AWS_CLOUDFORMATION_HOME=/opt/aws/apitools/cfn
         export PATH=$AWS_CLOUDFORMATION_HOME/bin:$AWS_ELASTICACHE_HOME/bin:$PATH
         export AWS_CREDENTIAL_FILE=/etc/cfn/cfn-credentials
         export JAVA_HOME=/usr/lib/jvm/jre
   
         # Grab the Cache node names and configure the PHP page
         aws cloudformation list-stack-resources --stack `{ "Ref" : "AWS::StackName" }` --region `{ "Ref" : "AWS::Region" }` --output text | grep MyElastiCache | awk '{print $4}' | xargs -I {} aws elasticache describe-cache-clusters --cache-cluster-id {} --region `{ "Ref" : "AWS::Region" }` --show-cache-node-info --output text | grep '^ENDPOINT' | awk '{print $2 ":" $3}' > `{ "Fn::GetOptionSetting" : { "OptionName" : "NodeListPath", "DefaultValue" : "/var/www/html/nodelist" } }`
       mode : "000500"
       owner : root
       group : root
   
     "/etc/cfn/hooks.d/cfn-cache-change.conf" :
       "content": |
         [cfn-cache-size-change]
         triggers=post.update
         path=Resources.AWSEBAutoScalingGroup.Metadata.ElastiCacheConfig
         action=/etc/cfn/get-cache-nodes
         runas=root
   
   sources :
     "/home/ec2-user/elasticache" : "https://elasticache-downloads.s3.amazonaws.com/AmazonElastiCacheCli-latest.zip"
   
   commands: 
     make-elasticache-executable:
       command: chmod -R ugo+x /home/ec2-user/elasticache/*/bin/*
   
   packages : 
     "yum" :
       "aws-apitools-cfn"  : []
   
   container_commands:
     initial_cache_nodes:
       command: /etc/cfn/get-cache-nodes
   ```

1. 在您的本機電腦上，使用下列程式碼片段來建立組態檔案 `nodejs-example-express-elasticache/.ebextensions/elasticache_settings.config` 以設定 ElastiCache。

   ```
   option_settings:
     "aws:elasticbeanstalk:customoption":
        CacheNodeType: cache.t2.micro
        NumCacheNodes: 1
        Engine: memcached
        NodeListPath: /var/nodelist
   ```

1. 在您的本機電腦上使用以下程式碼片段取代 `nodejs-example-express-elasticache/express-app.js` 。這個檔案會從磁碟 (`/var/nodelist`) 讀取節點清單，並設定 express 以使用 `memcached` 做為工作階段存放區 (若節點存在)。您的檔案看起來應該如下所示。

   ```
   /**
    * Module dependencies.
    */
   
   var express = require('express'),
       session = require('express-session'),
       bodyParser = require('body-parser'),
       methodOverride = require('method-override'),
       cookieParser = require('cookie-parser'),
       fs = require('fs'),
       filename = '/var/nodelist',
       app = module.exports = express();
   
   var MemcachedStore = require('connect-memcached')(session);
   
   function setup(cacheNodes) {
     app.use(bodyParser.raw());
     app.use(methodOverride());
     if (cacheNodes) {
         app.use(cookieParser());
   
         console.log('Using memcached store nodes:');
         console.log(cacheNodes);
   
         app.use(session({
             secret: 'your secret here',
             resave: false,
             saveUninitialized: false,
             store: new MemcachedStore({'hosts': cacheNodes})
         }));
     } else {
       console.log('Not using memcached store.');
       app.use(cookieParser('your secret here'));
       app.use(session());
     }
   
     app.get('/', function(req, resp){
     if (req.session.views) {
         req.session.views++
         resp.setHeader('Content-Type', 'text/html')
         resp.write('Views: ' + req.session.views)
         resp.end()
      } else {
         req.session.views = 1
         resp.end('Refresh the page!')
       }
     });
   
     if (!module.parent) {
         console.log('Running express without cluster.');
         app.listen(process.env.PORT || 5000);
     }
   }
   
   // Load elasticache configuration.
   fs.readFile(filename, 'UTF8', function(err, data) {
       if (err) throw err;
   
       var cacheNodes = [];
       if (data) {
           var lines = data.split('\n');
           for (var i = 0 ; i < lines.length ; i++) {
               if (lines[i].length > 0) {
                   cacheNodes.push(lines[i]);
               }
           }
       }
       setup(cacheNodes);
   });
   ```

1. 在本機電腦上，使用以下內容更新 `package.json`：

   ```
     "dependencies": {
       "cookie-parser": "~1.4.4",
       "debug": "~2.6.9",
       "express": "~4.16.1",
       "http-errors": "~1.6.3",
       "jade": "~1.11.0",
       "morgan": "~1.9.1",
       "connect-memcached": "*",
       "express-session": "*",
       "body-parser": "*",
       "method-override": "*"   
     }
   ```

1. 執行 **npm install**。

   ```
   ~/nodejs-example-express-elasticache$ npm install
   ```

1. 部署已更新的應用程式。

   ```
   ~/nodejs-example-express-elasticache$ eb deploy
   ```

1. 您的環境將在幾分鐘後更新。您的環境為綠色且就緒後，請確認該程式碼正常運作。

   1. 查看 [Amazon CloudWatch 主控台](https://console.aws.amazon.com/cloudwatch/home)來檢視您的 ElastiCache 指標。要查看您的 ElastiCache 指標，選取 **Metrics (指標)**，然後在左側窗格中搜尋 **CurrItems**。選取 **ElastiCache > Cache Node Metrics (ElastiCache > 快取節點指標)**，然後選取您的快取節點以檢視快取中的項目數量。  
![\[CloudWatch dashboard showing CurrItems metric for an ElastiCache node over time.\]](http://docs.aws.amazon.com/zh_tw/elasticbeanstalk/latest/dg/images/elasticache-express.png)
**注意**  
請確認您查看的是應用程式所部署的相同區域。

      若您複製應用程式 URL 並貼上至另一個 Web 瀏覽器，接著再重新整理該頁面，則應看到您的 CurrItem 計數在 5 分鐘後上升。

   1. 擷取您記錄日誌的快照。如需擷取日誌的詳細資訊，請參閱[在 Elastic Beanstalk 環境中檢視 Amazon EC2 執行個體的日誌](using-features.logging.md)。

   1. 檢查日誌服務包中的檔案 `/var/log/nodejs/nodejs.log`。您應該會看到類似下列的內容：

      ```
      Using memcached store nodes:
      [ 'aws-my-1oys9co8zt1uo.1iwtrn.0001.use1.cache.amazonaws.com:11211' ]
      ```

## 清除
<a name="nodejs-express-clustering.delete"></a>

若您不想要再執行您的應用程式，可以終止您的環境並刪除您的應用程式來清除。

請使用 `eb terminate` 命令來終止您的環境，並使用 `eb delete` 命令來刪除您的應用程式。

**終止環境**

請從您建立本機存放庫的目錄中，執行 `eb terminate`。

```
$ eb terminate
```

此程序需要幾分鐘的時間。Elastic Beanstalk 會在成功終止環境後顯示訊息。

# 將 Node.js 應用程式與 DynamoDB 部署到 Elastic Beanstalk
<a name="nodejs-dynamodb-tutorial"></a>

本教學課程及其範例應用程式 [nodejs-example-dynamo.zip](samples/nodejs-example-dynamo.zip) 會逐步引導您部署 Node.js 應用程式，該應用程式使用 Node.js 中適用於 JavaScript 的 AWS SDK 與 Amazon DynamoDB 服務互動。您將建立 DynamoDB 資料表，該資料表位於與 AWS Elastic Beanstalk 環境分離或外部的資料庫中。您也需設定應用程式，以使用分開的資料庫。在生產環境中，最佳做法是使用與 Elastic Beanstalk 環境分開的資料庫，以使其獨立於環境的生命週期。此做法也可讓您執行[藍/綠部署](using-features.CNAMESwap.md)。

範例應用程式可說明下列項目：
+ 儲存使用者提供之文字資料的 DynamoDB 資料表。
+ [組態檔案](ebextensions.md)，可用於建立資料表。
+ Amazon Simple Notification Service 主題。
+  於部署期間使用 [package.json 檔案](nodejs-platform-dependencies.md#nodejs-platform-packagejson)，以安裝套件。

**Topics**
+ [先決條件](#nodejs-dynamodb-tutorial-prereqs)
+ [建立 Elastic Beanstalk 環境](#nodejs-dynamodb-tutorial-launch)
+ [新增您環境執行個體的許可](#nodejs-dynamodb-tutorial-role)
+ [部署範例應用程式](#nodejs-dynamodb-tutorial-deploy)
+ [建立 DynamoDB 資料表](#nodejs-dynamodb-tutorial-database)
+ [更新應用程式的組態檔案](#nodejs-dynamodb-tutorial-update)
+ [將您的環境設定為高可用性](#nodejs-dynamodb-tutorial-configure)
+ [清除](#nodejs-dynamodb-tutorial-cleanup)
+ [後續步驟](#nodejs-dynamodb-tutorial-nextsteps)

## 先決條件
<a name="nodejs-dynamodb-tutorial-prereqs"></a>

本教學課程需要下列先決條件：
+ Node.js 執行階段
+ 預設的 Node.js 套件管理工具軟體 npm
+ Express 命令列產生器
+ Elastic Beanstalk 命令列界面 (EB CLI)

有關安裝所列出之前三個元件和設定本機開發環境的詳細資訊，請參閱 [設定 Elastic Beanstalk 的 Node.js 開發環境](nodejs-devenv.md)。在本教學課程中，您不需要安裝適用於 Node.js 的 AWS SDK，這也在參考主題中提及。

有關安裝和設定 EB CLI 的詳細資訊，請參閱 [使用設定指令碼安裝 EB CLI （建議）](eb-cli3.md#eb-cli3-install) 和 [設定 EB CLI](eb-cli3-configuration.md)。

## 建立 Elastic Beanstalk 環境
<a name="nodejs-dynamodb-tutorial-launch"></a>

**應用程式目錄**  
對於應用程式原始碼套件，本教學課程使用的是名為 `nodejs-example-dynamo` 的目錄。為本教學課程建立 `nodejs-example-dynamo` 目錄。

```
~$ mkdir nodejs-example-dynamo
```

**注意**  
本章中的每個教學課程皆會使用其自身的應用程式原始碼套件目錄。目錄名稱與教學課程所使用的範例應用程式名稱相符。

將您目前的工作目錄變更為 `nodejs-example-dynamo`。

```
~$ cd nodejs-example-dynamo
```

現在，來設定執行 Node.js 平台和範例應用程式的 Elastic Beanstalk 環境。我們將會使用 Elastic Beanstalk 命令列介面 (EB CLI)。

**設定應用程式的 EB CLI 儲存庫，並建立執行 Node.js 平台的 Elastic Beanstalk 環境**

1. 使用 **[**eb init**](eb3-init.md)** 命令建立一個儲存庫。

   ```
   ~/nodejs-example-dynamo$ eb init --platform node.js --region <region>
   ```

   此命令會在名為 `.elasticbeanstalk` 的資料夾內建立組態檔案，其中會指定應用程式使用的環境設定，並以目前資料夾為名建立 Elastic Beanstalk 應用程式。

1. 使用 **[**eb create**](eb3-create.md)** 命令建立執行範例應用程式的環境。

   ```
   ~/nodejs-example-dynamo$ eb create --sample nodejs-example-dynamo
   ```

   本命令會使用 Node.js 平台的預設設定和下列資源，建立負載平衡的環境：
   + **EC2 執行個體** ‒ Amazon Elastic Compute Cloud (Amazon EC2) 虛擬機器，已設為在您選擇的平台上執行 Web 應用程式。

     每個平台會執行特定的一套軟體、設定檔和指令碼，來支援特定的語言版本、架構、Web 容器或其組合。大多數的平台使用會 Apache 或 NGINX 做為反向代理，此反向代理會在您 Web 應用程式的前景執行、轉傳遞交給此 Web 應用程式的請求、提供靜態資產，並產生存取和錯誤日誌。
   + **執行個體安全群組** - Amazon EC2 安全群組，已設為允許從連接埠 80 傳入的流量。此資源可讓負載平衡器傳來的 HTTP 傳輸資料，到達執行您 Web 應用程式的 EC2 執行個體。在預設情況下，不允許傳輸資料從其他通訊埠傳送。
   + **負載平衡器** - Elastic Load Balancing 負載平衡器，可設定將請求分配到執行您應用程式的執行個體。負載平衡器也讓您的執行個體不需直接連接到網際網路。
   + **負載平衡器安全群組** - Amazon EC2 安全群組，設為允許從連接埠 80 傳入的流量。此資源可讓來自網際網路的 HTTP 傳輸資料到達負載平衡器。在預設情況下，不允許傳輸資料從其他通訊埠傳送。
   + **Auto Scaling 群組** - Auto Scaling 群組，設為在執行個體終止或無法使用時，取代該執行個體。
   + **Amazon S3 儲存貯體** - 儲存位置，用來儲存當您使用 Elastic Beanstalk 時所建立的原始程式碼、日誌和其他成品。
   + **Amazon CloudWatch 警示** - 兩種 CloudWatch 警示，用來監控您環境中執行個體上的負載，會在負載過高或過低時觸發。當警示觸發時，您的 Auto Scaling 群組會擴展或縮減以進行回應。
   + **CloudFormation 堆疊** – Elastic Beanstalk 使用 CloudFormation 啟動環境中的資源並傳播組態變更。資源定義於範本中，您可在 [CloudFormation 主控台](https://console.aws.amazon.com/cloudformation)中檢視此範本。
   + **網域名稱** – 會路由到您 Web 應用程式的網域名稱，其格式為 **subdomain*.*region*.elasticbeanstalk.com*。
**網域安全**  
為了增強 Elastic Beanstalk 應用程式的安全性，我們會在[公共后缀列表 (PSL)](https://publicsuffix.org/) 中註冊網域 *elasticbeanstalk.com*。  
如果您需要在 Elastic Beanstalk 應用程式的預設網域名稱中設定敏感 Cookie，建議您使用字`__Host-`首為 的 Cookie 以提高安全性。此實務可保護您的網域免於跨網站請求偽造嘗試 (CSRF)。如需更多資訊，請參閱 Mozilla 開發人員網路中的[設定 Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes) 頁面。

1. 環境建立完成後，請使用 [**eb open**](eb3-open.md) 命令，在預設瀏覽器中開啟環境 URL。

   ```
   ~/nodejs-example-dynamo$ eb open
   ```

您現在已使用範例應用程式建立 Node.js Elastic Beanstalk 環境。您可以使用自己的應用程式對其進行更新。接下來，我們會更新範例應用程式，以使用 Express 架構。

## 新增您環境執行個體的許可
<a name="nodejs-dynamodb-tutorial-role"></a>

您的應用程式會執行於負載平衡器後方的一個或多個 EC2 執行個體上，處理來自網際網路的 HTTP 請求。當應用程式收到要求其使用 AWS 服務的請求時，應用程式會使用其執行的執行個體許可來存取這些服務。

本範例應用程式會使用執行個體的許可將資料寫入 DynamoDB 資料表，並透過適用於 Node.js 中 JavaScript 的開發套件，將通知傳送至 Amazon SNS 主題。將下列受管原則新增至預設[執行個體設定檔](concepts-roles-instance.md)，以授予您環境中的 EC2 執行個體存取 DynamoDB 和 Amazon SNS 的許可：
+ **AmazonDynamoDBFullAccess**
+ **AmazonSNSFullAccess**

**若要在預設的執行個體設定檔中新增原則**

1. 在 IAM 主控台中開啟 [Roles (角色) 頁面](https://console.aws.amazon.com/iam/home#roles)。

1. 請選擇 **aws-elasticbeanstalk-ec2-role (aws-elasticbeanstalk-ec2-role)**。

1. 在 **Permissions** (許可) 標籤上，選擇 **Attach policies** (連接政策)。

1. 為您的應用程式使用的其他服務，選取受管原則，對於本教學課程，請選取 `AmazonSNSFullAccess` 和 `AmazonDynamoDBFullAccess`。

1. 選擇**連接政策**。

如需管理執行個體設定檔的詳細資訊，請參閱 [管理 Elastic Beanstalk 執行個體描述檔](iam-instanceprofile.md)。

## 部署範例應用程式
<a name="nodejs-dynamodb-tutorial-deploy"></a>

現在，您的環境已可供部署，並可執行本教學課程的範例應用程式：[nodejs-example-dynamo.zip](samples/nodejs-example-dynamo.zip)。

**部署和執行教學課程範例應用程式**

1. 將目前的工作目錄變更為應用程式目錄 `nodejs-example-dynamo`。

   ```
   ~$ cd nodejs-example-dynamo
   ```

1. 將範例應用程式原始碼套件 [nodejs-example-dynamo.zip](samples/nodejs-example-dynamo.zip) 的內容下載並解壓縮至應用程式目錄 `nodejs-example-dynamo`。

1. 使用 [**eb deploy**](eb3-deploy.md) 命令將範例應用程式部署至您的 Elastic Beanstalk 環境。

   ```
   ~/nodejs-example-dynamo$ eb deploy
   ```
**注意**  
根據預設， `eb deploy`命令會建立專案資料夾的 ZIP 檔案。您亦可設定 EB CLI 從建置程序部署組建成品，而非建立您專案資料夾的 ZIP 檔案。如需詳細資訊，請參閱[部署成品而非專案資料夾](eb-cli3-configuration.md#eb-cli3-artifact)。

1. 環境建立完成後，請使用 [**eb open**](eb3-open.md) 命令，在預設瀏覽器中開啟環境 URL。

   ```
   ~/nodejs-example-dynamo$ eb open
   ```

本站點會收集使用者聯絡資訊，並使用 DynamoDB 資料表來存放資料。欲新增項目，選擇 **Sign up today (立即註冊)**，輸入名稱和電子郵件地址，然後選擇 **Sign Up\$1 (註冊！)**。本 Web 應用程式會將表單內容寫入資料表，並觸發 Amazon SNS 電子郵件通知。

![\[Startup landing page with teaser message and sign-up button for upcoming product launch.\]](http://docs.aws.amazon.com/zh_tw/elasticbeanstalk/latest/dg/images/nodejs-dynamodb-tutorial-app.png)


現在，Amazon SNS 主題會透過通知用的預留位置電子郵件進行設定。您很快就會更新此組態，但您可同時在 AWS 管理主控台內驗證 DynamoDB 資料表和 Amazon SNS 主題。

**欲檢視資料表**

1. 在 DynamoDB 主控台中開啟[資料表頁面](https://console.aws.amazon.com/dynamodb/home?#tables:)。

1. 尋找應用程式建立的資料表。名稱開頭為 **awseb**，而且其中包含 **StartupSignupsTable**。

1. 選取資料表，選擇 **Items (項目)**，然後選擇 **Start search (開始搜尋)** 以檢視資料表的所有項目。

於註冊網站提交的每個電子郵件地址，在資料表內均有一個項目。本應用程式除了寫入資料表，亦會傳送訊息至具有兩個訂閱的 Amazon SNS 主題，一個用於向您發送電子郵件通知，另一個則用於 Amazon Simple Queue Service 佇列，工作者應用程式可自其中讀取以處理請求並傳送電子郵件至感興趣的客戶。

**欲檢視主題**

1. 在 Amazon SNS 主控台中開啟[主題頁面](https://console.aws.amazon.com/sns/v2/home?#/topics)。

1. 尋找應用程式建立的主題。名稱開頭為 **awseb**，而且其中包含 **NewSignupTopic**。

1. 選擇主題以檢視其訂閱。

應用程式 (`[app.js](https://github.com/awslabs/eb-node-express-sample/blob/master/app.js)`) 會定義兩個路由。根路徑 (`/`) 會回傳轉譯自嵌入式 JavaScript (EJS) 範本的網頁及一份表單，使用者須填寫表單以註冊他們的名稱和電子郵件地址。提交表單會將內含表單資料的 POST 請求傳送至 `/signup` 路由，該路由會寫入 DynamoDB 資料表，並發佈訊息至 Amazon SNS 主題以通知擁有者註冊事宜。

本範例應用程式內含[組態檔案](ebextensions.md)，其可建立 DynamoDB 資料表、Amazon SNS 主題和應用程式所使用的 Amazon SQS 佇列。這可讓您建立新的環境並立即測試功能，但缺點是將 DynamoDB 資料表與環境綁定。以生產環境而言，您應於環境外建立 DynamoDB 資料表，以避免您終止環境或更新其組態時遺失該資料表。

## 建立 DynamoDB 資料表
<a name="nodejs-dynamodb-tutorial-database"></a>

欲搭配於 Elastic Beanstalk 執行的應用程式使用外部 DynamoDB 資料表，請先於 DynamoDB 建立資料表。當您在 Elastic Beanstalk 外建立資瞭表時，它完全獨立於 Elastic Beanstalk 和您的 Elastic Beanstalk 環境，並且不會被 Elastic Beanstalk 終止。

透過下列設定建立資料表：
+ **Table name (資料表名稱)** – **nodejs-tutorial** 
+ **主索引鍵** – **email**
+ 主索引鍵類型 – **String (字串)**

**建立 DynamoDB 資料表**

1. 在 DynamoDB 管理主控台中開啟[資料表頁面](https://console.aws.amazon.com/dynamodb/home?#tables:)。

1. 選擇 **Create Table** (建立資料表)。

1. 輸入 **Table name (資料表名稱) **和 **Primary key (主索引鍵)**。

1. 選擇主索引鍵類型。

1. 選擇**建立**。

## 更新應用程式的組態檔案
<a name="nodejs-dynamodb-tutorial-update"></a>

更新應用程式原始碼內的[組態檔案](ebextensions.md)以使用 **nodejs-tutorial (nodejs-tutorial)** 資料表，無須建立新的資料表。

**更新範例應用程式，以供生產使用**

1. 將目前的工作目錄變更為應用程式目錄 `nodejs-example-dynamo`。

   ```
   ~$ cd nodejs-example-dynamo
   ```

1. 開啟 `.ebextensions/options.config` 並變更下列設定的值：
   + **NewSignupEmail** – 您的電子郵件地址。
   + **STARTUP\$1SIGNUP\$1TABLE** – **nodejs-tutorial**

     
**Example .ebextensions/options.config**  

   ```
   option_settings:
     aws:elasticbeanstalk:customoption:
       NewSignupEmail: you@example.com
     aws:elasticbeanstalk:application:environment:
       THEME: "flatly"
       AWS_REGION: '`{"Ref" : "AWS::Region"}`'
       STARTUP_SIGNUP_TABLE: nodejs-tutorial
       NEW_SIGNUP_TOPIC: '`{"Ref" : "NewSignupTopic"}`'
     aws:elasticbeanstalk:container:nodejs:
       ProxyServer: nginx
     aws:elasticbeanstalk:container:nodejs:staticfiles:
       /static: /static
     aws:autoscaling:asg:
       Cooldown: "120"
     aws:autoscaling:trigger:
       Unit: "Percent"
       Period: "1"
       BreachDuration: "2"
       UpperThreshold: "75"
       LowerThreshold: "30"
       MeasureName: "CPUUtilization"
   ```

   這將為應用程式套用以下設定：
   + Amazon SNS 主題用於通知的電子郵件地址會設為您的地址，或您於 `options.config` 檔案中輸入的地址。
   + 系統將會使用 **nodejs-tutorial** 資料表，而非 `.ebextensions/create-dynamodb-table.config` 所建立的資料表。

1. 移除 `.ebextensions/create-dynamodb-table.config`。

   ```
   ~/nodejs-tutorial$ rm .ebextensions/create-dynamodb-table.config
   ```

   您下次部署應用程式時，將刪除此組態檔案建立的資料表。

1. 使用 [**eb deploy**](eb3-deploy.md) 命令將更新的應用程式部署至您的 Elastic Beanstalk 環境。

   ```
   ~/nodejs-example-dynamo$ eb deploy
   ```

1. 環境建立完成後，請使用 [**eb open**](eb3-open.md) 命令，在預設瀏覽器中開啟環境 URL。

   ```
   ~/nodejs-example-dynamo$ eb open
   ```

當您部署時，Elastic Beanstalk 會更新 Amazon SNS 主題的組態，並刪除您部署應用程式第一個版本時建立的 DynamoDB 資料表。

現在，當您終止環境時，將無法刪除 **nodejs-tutorial (nodejs-tutorial)** 資料表。這可讓您執行藍/綠部署、修改組態檔案或關閉您的網站而不會遺失資料。

在瀏覽器中開啟您的網站，並確認表單如預期運作。建立數個項目，然後檢查 DynamoDB 主控台來驗證資料表。

**欲檢視資料表**

1. 在 DynamoDB 主控台中開啟[資料表頁面](https://console.aws.amazon.com/dynamodb/home?#tables:)。

1. 尋找 **nodejs-tutorial (nodejs-tutorial)** 資料表。

1. 選取資料表，選擇 **Items (項目)**，然後選擇 **Start search (開始搜尋)** 以檢視資料表的所有項目。

您也可看到 Elastic Beanstalk 已刪除之前建立的資料表。

## 將您的環境設定為高可用性
<a name="nodejs-dynamodb-tutorial-configure"></a>

最後，請增加執行個體計數下限，藉此設定您的環境 Auto Scaling 群組。隨時至少執行兩個執行個體，避免您環境中的 Web 伺服器出現單點故障，且無須停止網站服務即可部署變更。

**若要設定您環境的 Auto Scaling 群組，以維持高可用性**

1. 開啟 [Elastic Beanstalk 主控台](https://console.aws.amazon.com/elasticbeanstalk)，然後在**區域**清單中選取您的 AWS 區域。

1. 在導覽窗格中，選擇**環境**，然後在清單中選擇您環境的名稱。

1. 在導覽窗格中，選擇 **Configuration** (組態)。

1. 在 **Capacity (容量)** 組態類別中，選擇 **Edit (編輯)**。

1. 在 **Auto Scaling 群組**區段，將**最小執行個體**設定為 **2**。

1. 若要儲存變更，請選擇頁面底部的**儲存變更**。

## 清除
<a name="nodejs-dynamodb-tutorial-cleanup"></a>

完成使用示範程式碼後，您可以終止您的環境。Elastic Beanstalk 會刪除所有相關 AWS 資源，例如 [Amazon EC2 執行個體](using-features.managing.ec2.md)、[資料庫執行個體](using-features.managing.db.md)、[負載平衡器](using-features.managing.elb.md)、安全群組和[警示](using-features.alarms.md#using-features.alarms.title)。

移除資源不會刪除 Elastic Beanstalk 應用程式，因此您可以隨時為您的應用程式建立新環境。

**從主控台終止您的 Elastic Beanstalk 環境**

1. 開啟 [Elastic Beanstalk 主控台](https://console.aws.amazon.com/elasticbeanstalk)，然後在**區域**清單中選取您的 AWS 區域。

1. 在導覽窗格中，選擇**環境**，然後在清單中選擇您環境的名稱。

1. 選擇 **Actions** (動作)，然後選擇 **Terminate Environment** (終止環境)。

1. 使用畫面顯示對話方塊來確認環境終止。

您也可以刪除您所建立的外部 DynamoDB 資料表。

**刪除 DynamoDB 資料表**

1. 在 DynamoDB 主控台中開啟[資料表頁面](https://console.aws.amazon.com/dynamodb/home?#tables:)。

1. 選擇資料表。

1. 選擇 **Actions (動作)**，然後再選擇 **Delete table (刪除資料表)**。

1. 選擇 **刪除**。

## 後續步驟
<a name="nodejs-dynamodb-tutorial-nextsteps"></a>

範例應用程式使用組態檔案來設定軟體設定，並建立 AWS 資源做為您環境的一部分。如需關於組態檔案及其用途的詳細資訊，請參閱 [使用組態檔案 (`.ebextensions`) 來進行進階的環境自訂](ebextensions.md)。

本教學課程的範例應用程式使用 Node.js 適用的 Express Web 架構。如需有關 Express 的詳細資訊，請至 [expressjs.com](https://expressjs.com) 參閱其官方文件。

最後，若您打算於生產環境中使用您的應用程式，請[設定您環境的自訂網域名稱](customdomains.md)，並[啟用 HTTPS](configuring-https.md) 安全連線。

# 將 Amazon RDS 資料庫執行個體新增至 Node.js Elastic Beanstalk 環境
<a name="create-deploy-nodejs.rds"></a>

本主題提供了使用 Elastic Beanstalk 主控台建立 Amazon RDS 的說明。您可以使用 Amazon Relational Database Service (Amazon RDS) 資料庫執行個體存放由應用程式收集與修改的資料。資料庫可與環境耦合並由 Elastic Beanstalk 管理，或者由另一項服務在外部分開建立與管理。在這些指示中，資料庫會與您的環境耦合，並由 Elastic Beanstalk 管理。如需將 Amazon RDS 與 Elastic Beanstalk 整合的相關詳細資訊，請參閱 [將資料庫新增至您的 Elastic Beanstalk 環境](using-features.managing.db.md)。

**Topics**
+ [將資料庫執行個體新增到您的環境](#nodejs-rds-create)
+ [下載驅動程式](#nodejs-rds-drivers)
+ [連線至資料庫](#nodejs-rds-connect)

## 將資料庫執行個體新增到您的環境
<a name="nodejs-rds-create"></a>

**欲將資料庫執行個體新增到您的環境**

1. 開啟 [Elastic Beanstalk 主控台](https://console.aws.amazon.com/elasticbeanstalk)，然後在**區域**清單中選取您的 AWS 區域。

1. 在導覽窗格中，選擇**環境**，然後在清單中選擇您環境的名稱。

1. 在導覽窗格中，選擇 **Configuration (組態)**。

1. 在 **Database (資料庫)** 組態類別中，選擇 **Edit (編輯)**。

1. 選擇資料庫引擎，並輸入使用者名稱和密碼。

1. 若要儲存變更，請選擇頁面底部的**儲存變更**。

新增資料庫執行個體約需要 10 分鐘。環境更新完成時，資料庫執行個體的主機名稱和其他連線資訊會透過下列環境屬性提供給您的應用程式：


| 屬性名稱 | 描述 | 屬性值 | 
| --- | --- | --- | 
|  `RDS_HOSTNAME`  |  資料庫執行個體的主機名稱。  |  在 Amazon RDS 主控台：**端點**的**連線能力和安全性**索引標籤上。  | 
|  `RDS_PORT`  |  資料庫執行個體接受連線的連接埠。預設值在不同資料庫引擎中有所差異。  |  在 Amazon RDS 主控台：**連接埠**的**連線能力和安全性**索引標籤上。  | 
|  `RDS_DB_NAME`  |  資料庫名稱，**ebdb**。  |  在 Amazon RDS 主控台：**資料庫名稱**的**組態**索引標籤上。  | 
|  `RDS_USERNAME`  |  您為資料庫設定的使用者名稱。  |  在 Amazon RDS 主控台：**主要使用者名稱**的**組態**索引標籤上。  | 
|  `RDS_PASSWORD`  |  您為資料庫設定的密碼。  |  無法在 Amazon RDS 主控台中提供參考。  | 

如需設定與 Elastic Beanstalk 環境耦合之資料庫執行個體的相關詳細資訊，請參閱 [將資料庫新增至您的 Elastic Beanstalk 環境](using-features.managing.db.md)。

## 下載驅動程式
<a name="nodejs-rds-drivers"></a>

將資料庫驅動程式新增到您專案的 [`package.json` 檔案](nodejs-platform-dependencies.md#nodejs-platform-packagejson)的 `dependencies` 中。

**Example `package.json` – Express 搭配 MySQL**  

```
{
  "name": "my-app",
  "version": "0.0.1",
  "private": true,
  "dependencies": {
    "ejs": "latest",
    "aws-sdk": "latest",
    "express": "latest",
    "body-parser": "latest",
    "mysql": "latest"
  },
  "scripts": {
    "start": "node app.js"
  }
}
```

**適用於 Node.js 的常見驅動程式套件**
+ **MySQL** – [mysql](https://www.npmjs.com/package/mysql)
+ **PostgreSQL** – [node-postgres](https://www.npmjs.com/package/pg)
+ **SQL Server** – [node-mssql](https://www.npmjs.com/package/mssql)
+ **Oracle** – [node-oracledb](https://www.npmjs.com/package/oracledb)

## 連線至資料庫
<a name="nodejs-rds-connect"></a>

Elastic Beanstalk 會在環境屬性中提供已連接的資料庫執行個體連線資訊。使用 `process.env.VARIABLE` 來讀取屬性和設定資料庫的連線。

**Example app.js – MySQL 資料庫連線**  

```
var mysql = require('mysql');

var connection = mysql.createConnection({
  host     : process.env.RDS_HOSTNAME,
  user     : process.env.RDS_USERNAME,
  password : process.env.RDS_PASSWORD,
  port     : process.env.RDS_PORT
});

connection.connect(function(err) {
  if (err) {
    console.error('Database connection failed: ' + err.stack);
    return;
  }

  console.log('Connected to database.');
});

connection.end();
```
關於使用 node-mysql 來建構連線字串，詳細資訊請參閱 [npmjs.org/package/mysql](https://npmjs.org/package/mysql)。

# Node.js 工具和資源
<a name="create_deploy_nodejs.resources"></a>

在開發 Node.js 應用程式時，您可以造訪幾個地方來取得額外的協助：


****  

|  資源  |  Description  | 
| --- | --- | 
|  [GitHub](https://github.com/aws/aws-sdk-js)  | 使用 GitHub 安裝適用於 Node.js 的 AWS SDK。 | 
|  [AWS 適用於 Node.js 的 SDK （開發人員預覽版）](https://aws.amazon.com/sdkfornodejs/)  | 可取得範本程式碼、文件、工具和其他資源等一應俱全的場所。 | 