

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

# 使用 Elastic Beanstalk 部署 Java 應用程式
<a name="create_deploy_Java"></a>

本章提供設定和部署 Java 應用程式的說明 AWS Elastic Beanstalk。Elastic Beanstalk 可讓您使用 Amazon Web Services 輕鬆部署、管理和擴展 Java Web 應用程式。

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

遵循 [適用於 Java 的 QuickStart ](java-quickstart.md)的逐步說明，使用 EB CLI 建立和部署 *Hello World* Java Web 應用程式。 step-by-step 如果您對建立簡單的 *Hello World* Java JSP 應用程式以使用 EB CLI 部署到 Tomcat 型平台step-by-step說明感興趣，請嘗試 [Tomcat 上的適用於 Java 的 QuickStart ](tomcat-quickstart.md)。

**Java 平台分支**  
AWS Elastic Beanstalk 支援適用於 Java 應用程式的兩個平台。
+ **Tomcat** – 以 *Apache Tomcat* 為基礎的平台，它是一種開放原始碼的 Web 容器，適用於使用 Java Servlet 和 JavaServer Pages (JSP) 來處理 HTTP 請求的應用程式。Tomcat 提供了多執行緒、宣告式的安全組態與豐富的自訂功能，來協助 Web 應用程式的開發。Elastic Beanstalk 為每個 Tomcat 目前主要版本都提供平台分支。如需更多詳細資訊，請參閱 [Tomcat 平台](java-tomcat-platform.md)。
+ **Java SE** – 這種平台適用於不使用 Web 容器的應用程式，或使用 Jetty 或 GlassFish 等 Tomcat 之外容器的應用程式。您可以在部署到 Elastic Beanstalk 的原始碼套件中，加入應用程式所使用的任何程式庫 Java Archive (JAR)。如需詳細資訊，請參閱[Java SE 平台](java-se-platform.md)。

Tomcat 和 Java SE 平台最近的分支都以 Amazon Linux 2 和更新版本為基礎，並使用 *Corretto* - AWS Java SE 發行版本。這些平台分支的名稱包含 *Corretto* 而非 *Java* 一詞。

如需目前平台版本清單，請參閱 *AWS Elastic Beanstalk 平台*指南中的 [Tomcat](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.java) 和 [Java SE](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.javase)。

**AWS 工具**  
AWS 提供數種使用 Java 和 Elastic Beanstalk 的工具。無論您選擇哪個平台分支，都可以使用適用於 [AWS Java 的 SDK](java-development-environment.md#java-development-environment-sdk) 來使用 Java 應用程式中的其他 AWS 服務。適用於 Java 的 AWS SDK 是一組程式庫，可讓您從應用程式程式碼使用 AWS APIs而無需從頭開始撰寫原始 HTTP 呼叫。

如果您想要從命令列管理您的應用程式，請安裝 [Elastic Beanstalk 命令列界面](eb-cli3.md) (EB CLI)，並使用它來建立、監控和管理 Elastic Beanstalk 環境。如果您針對應用程式執行了多個環境。則 EB CLI 會與 Git 整合，來讓您建立每個環境與不同 Git 分支的關聯。

**Topics**
+ [

# QuickStart：將 Java 應用程式部署到 Elastic Beanstalk
](java-quickstart.md)
+ [

# QuickStart：將 Tomcat 的 Java JSP Web 應用程式部署至 Elastic Beanstalk
](tomcat-quickstart.md)
+ [

# 設定您的 Java 開發環境
](java-development-environment.md)
+ [

# 更多適用於 Java 的 Elastic Beanstalk 範例應用程式和教學課程
](java-getstarted.md)
+ [

# 使用 Elastic Beanstalk Tomcat 平台
](java-tomcat-platform.md)
+ [

# 使用 Elastic Beanstalk Java SE 平台
](java-se-platform.md)
+ [

# 將 Amazon RDS 資料庫執行個體新增至 Java Elastic Beanstalk 環境
](java-rds.md)
+ [

# Java 工具和資源
](create_deploy_Java.resources.md)

# QuickStart：將 Java 應用程式部署到 Elastic Beanstalk
<a name="java-quickstart"></a>

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

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

**Topics**
+ [

## AWS 您的帳戶
](#java-quickstart-aws-account)
+ [

## 先決條件
](#java-quickstart-prereq)
+ [

## 步驟 1：建立 Java 應用程式
](#java-quickstart-create-app)
+ [

## 步驟 2：在本機執行您的應用程式
](#java-quickstart-run-local)
+ [

## 步驟 3：使用 EB CLI 部署您的 Java 應用程式
](#java-quickstart-deploy)
+ [

## 步驟 4：在 Elastic Beanstalk 上執行應用程式
](#java-quickstart-run-eb-ap)
+ [

## 步驟 5：清除
](#java-tutorial-cleanup)
+ [

## AWS 應用程式的 資源
](#java-quickstart-eb-resources)
+ [

## 後續步驟
](#java-quickstart-next-steps)
+ [

## 使用 Elastic Beanstalk 主控台部署
](#java-quickstart-console)

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

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

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

### 建立 AWS 帳戶
<a name="java-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="java-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="java-quickstart-prereq.ebcli"></a>

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

### Java 和 Maven
<a name="java-quickstart-prereq.runtime"></a>

如果您的本機電腦上未安裝 Amazon Corretto，您可以依照 *Amazon Corretto 使用者指南*中的安裝[說明進行安裝](https://docs.aws.amazon.com/corretto/latest/corretto-21-ug/amazon-linux-install.html)。

執行下列命令來驗證您的 Java 安裝。

```
~$ java -version 
```

本教學課程使用 Maven。請遵循 Apache Maven 專案網站上的[下載](https://maven.apache.org/download.cgi)和[安裝](https://maven.apache.org/install.html)說明。如需 Maven 的詳細資訊，請參閱 Apache [Maven 專案網站上的 Maven 使用者中心](https://maven.apache.org/users/index.html)。

執行下列命令來驗證您的 Maven 安裝。

```
~$ mvn -v
```

## 步驟 1：建立 Java 應用程式
<a name="java-quickstart-create-app"></a>

建立專案目錄。

```
~$ mkdir eb-java
~$ cd eb-java
```

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

此範例使用 [Spring Boot](https://spring.io/projects/spring-boot) 架構。此應用程式會在連接埠 5000 上開啟接聽程式。根據預設，Elastic Beanstalk 會將請求轉送至連接埠 5000 上的應用程式。

建立下列檔案：

此檔案會建立簡單的 Spring Boot 應用程式。

**Example `~/eb-java/src/main/java/com/example/Application.java`**  

```
package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
```

此檔案會建立映射，傳回我們在此處定義的字串。

**Example `~/eb-java/src/main/java/com/example/Controller.java`**  

```
package com.example;
    
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
    
@RestController
public class Controller {
    
    @GetMapping("/")
    public String index() {
       return "Hello Elastic Beanstalk!";
    }
}
```

此檔案定義 Maven 專案組態。

**Example `~/eb-java/pom.xml`**  

```
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.3</version>
  </parent>

  <groupId>com.example</groupId>
  <artifactId>BeanstalkJavaExample</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <java.version>21</java.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-rest</artifactId>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

</project>
```

此屬性檔案會覆寫預設連接埠為 5000。這是 Elastic Beanstalk 為 Java 應用程式傳送流量到 的預設連接埠。

**Example `~/eb-java/application.properties`**  

```
server.port=5000
```

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

使用下列命令封裝您的應用程式：

```
~/eb-java$ mvn clean package
```

使用下列命令在本機執行應用程式：

```
~/eb-java$ java -jar target/BeanstalkJavaExample-1.0-SNAPSHOT.jar
```

應用程式執行時，請在瀏覽器`http://127.0.0.1:5000/`中導覽至 。您應該會看到「Hello Elastic Beanstalk！」文字。

## 步驟 3：使用 EB CLI 部署您的 Java 應用程式
<a name="java-quickstart-deploy"></a>

在將 Java 應用程式部署至 Elastic Beanstalk 之前，讓我們先從目錄中清除建置應用程式，並建立 [Buildfile](java-se-buildfile.md) 和 [Procfile](java-se-procfile.md)，以控制應用程式在 Elastic Beanstalk 環境上的建置和執行方式。

**準備和設定應用程式部署**

1. 清理建置的應用程式。

   ```
   ~/eb-java$ mvn clean
   ```

1. 建立 `Buildfile`。  
**Example `~/eb-java/Buildfile`**  

   ```
   build: mvn clean package
   ```

   這會`Buildfile`指定用來建置應用程式的命令。如果您未包含`Buildfile`適用於 Java 應用程式的 ，Elastic Beanstalk 不會嘗試建置您的應用程式。

1. 建立 `Procfile`。  
**Example `~/eb-java/Procfile`**  

   ```
   web: java -jar target/BeanstalkJavaExample-1.0-SNAPSHOT.jar
   ```

   這會`Procfile`指定用來執行應用程式的命令。如果您未`Procfile`為 Java 應用程式包含 ，Elastic Beanstalk 會假設原始碼套件的根目錄中有一個 JAR 檔案，並嘗試使用 `java -jar`命令執行該檔案。

 現在您已設定組態檔案來建置和啟動應用程式，您已準備好進行部署。

**建立環境並部署您的 Java 應用程式**

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

   ```
   ~/eb-java eb init -p corretto java-tutorial --region us-east-2
           
   Application java-tutorial has been created.
   ```

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

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

   ```
   ~/eb-java$ 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 檔案，並在連接埠 5000 上啟動它。

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

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

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

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

```
~/eb-java eb open
```

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

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

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

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

```
~/eb-java$ eb terminate
```

## AWS 應用程式的 資源
<a name="java-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="java-quickstart-next-steps"></a>

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

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

部署範例應用程式一兩個，並準備好開始在本機開發和執行 Java 應用程式後，請參閱 [設定您的 Java 開發環境](java-development-environment.md)。

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

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

# QuickStart：將 Tomcat 的 Java JSP Web 應用程式部署至 Elastic Beanstalk
<a name="tomcat-quickstart"></a>

本教學課程將逐步引導您使用 JavaServer Pages (JSP) 建立簡單的 Java Web 應用程式。 JSPs 如果您想要在單一 Elastic Beanstalk 環境中以 WAR 檔案的形式綁定多個 Web 應用程式，請參閱 [綁定多個用於 Tomcat 環境的 WAR 檔案](java-tomcat-multiple-war-files.md)。

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

**Topics**
+ [

## AWS 您的帳戶
](#tomcat-quickstart-aws-account)
+ [

## 先決條件
](#tomcat-quickstart-prereq)
+ [

## 步驟 1：建立 Java JSP 應用程式
](#tomcat-quickstart-create-app)
+ [

## 步驟 2：使用 EB CLI 部署 Java JSP 應用程式
](#tomcat-quickstart-deploy)
+ [

## 步驟 3：在 Elastic Beanstalk 上執行應用程式
](#tomcat-quickstart-run-eb-ap)
+ [

## 步驟 4：清理
](#go-tutorial-cleanup)
+ [

## AWS 應用程式的 資源
](#tomcat-quickstart-eb-resources)
+ [

## 後續步驟
](#tomcat-quickstart-next-steps)
+ [

## 使用 Elastic Beanstalk 主控台部署
](#tomcat-quickstart-console)

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

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

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

### 建立 AWS 帳戶
<a name="tomcat-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="tomcat-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="tomcat-quickstart-prereq.ebcli"></a>

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

## 步驟 1：建立 Java JSP 應用程式
<a name="tomcat-quickstart-create-app"></a>

建立專案目錄。

```
~$ mkdir eb-tomcat
~$ cd eb-tomcat
```

接著，請建立您將使用 Elastic Beanstalk 進行部署的應用程式。我們將建立 "Hello World" Web 應用程式。

建立名為 的簡單 JSP 檔案`index.jsp`。

**Example `~/eb-tomcat/index.jsp`**  

```
<html>
  <body>
    <%out.println("Hello Elastic Beanstalk!");%>
  </body>
</html>
```

## 步驟 2：使用 EB CLI 部署 Java JSP 應用程式
<a name="tomcat-quickstart-deploy"></a>

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

 

**建立環境並部署 Java JSP 應用程式**

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

   ```
   ~/eb-tomcat$ eb init -p tomcat tomcat-tutorial --region us-east-2
   ```

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

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

   ```
   ~/eb-go$ 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 檔案，並在連接埠 5000 上啟動它。

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

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

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

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

```
~/eb-tomcat$ eb open
```

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

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

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

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

```
~/eb-tomcat$ eb terminate
```

## AWS 應用程式的 資源
<a name="tomcat-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="tomcat-quickstart-next-steps"></a>

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

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

部署範例應用程式一兩個，並準備好開始在本機 Tomcat Web 容器中開發和執行 Java 應用程式後，請參閱 [設定您的 Java 開發環境](java-development-environment.md)。

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

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

# 設定您的 Java 開發環境
<a name="java-development-environment"></a>

本主題提供設定 Java 開發環境的說明，以在本機測試您的應用程式，然後再部署到其中 AWS Elastic Beanstalk。它也參考提供實用工具安裝指示的網站。

**Topics**
+ [

## 安裝 Java 開發套件
](#java-development-environment-jdk)
+ [

## 安裝 Web 容器
](#java-development-environment-tomcat)
+ [

## 下載程式庫
](#java-development-environment-libraries)
+ [

## 安裝適用於 Java 的 AWS 開發套件
](#java-development-environment-sdk)
+ [

## 安裝 IDE 或文字編輯器
](#java-development-environment-ide)

## 安裝 Java 開發套件
<a name="java-development-environment-jdk"></a>

安裝 Java 開發套件 (JDK)。若您沒有特別需求，請取得最新版本。請至 [oracle.com](http://www.oracle.com/technetwork/java/javase/downloads/index.html) 下載 JDK 

JDK 內含 Java 編譯器，您可用其將來源檔案建立為可於 Elastic Beanstalk Web 伺服器上執行的類別檔案。

## 安裝 Web 容器
<a name="java-development-environment-tomcat"></a>

如果您還沒有其他 Web 容器或架構，請為 Amazon Linux 作業系統安裝 Elastic Beanstalk 支援的 Tomcat 版本。如需 Elastic Beanstalk 支援的目前 Apache Tomcat 版本清單，請參閱 *AWS Elastic Beanstalk 平台文件中的* [Tomcat](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.java)。從 [Apache Tomcat 網站下載適用於您環境的 Tomcat](http://tomcat.apache.org) 版本。

## 下載程式庫
<a name="java-development-environment-libraries"></a>

Elastic Beanstalk 平台預設包含幾個程式庫。下載您應用程式將使用的程式庫，並將其儲存在您的專案資料夾，以部署至應用程式原始碼套件。

若您已於本機安裝 Tomcat，可自安裝資料夾複製 servlet API 和 JavaServer Pages (JSP) API 程式庫。若您部署至 Tomcat 平台版本，則這些檔案無須納入原始碼套件，但必須納入 `classpath` 以編譯使用這些檔案的類別。

JUnit、Google Guava 和 Apache Commons 提供多種實用的程式庫。若要進一步了解，請造訪其首頁：
+  [下載 JUnit](https://github.com/junit-team/junit/wiki/Download-and-Install) 
+  [下載 Google Guava](https://code.google.com/p/guava-libraries/) 
+  [下載 Apache Commons](http://commons.apache.org/downloads/) 

## 安裝適用於 Java 的 AWS 開發套件
<a name="java-development-environment-sdk"></a>

如果您需要從應用程式中管理 AWS 資源，請安裝適用於 Java 的 AWS 開發套件。例如，透過 適用於 Java 的 AWS SDK，您可以使用 Amazon DynamoDB (DynamoDB) 在多個 Web 伺服器上共用 Apache Tomcat 應用程式的工作階段狀態。如需詳細資訊，請參閱適用於 Java 的 AWS SDK 文件中的[使用 Amazon DynamoDB 管理 Tomcat 工作階段狀態](https://docs.aws.amazon.com/AWSSdkDocsJava/latest/DeveloperGuide/java-dg-tomcat-session-manager.html)。

如需詳細資訊及安裝說明，請造訪[適用於 Java 的AWS 開發套件首頁](https://aws.amazon.com/sdk-for-java/)。

## 安裝 IDE 或文字編輯器
<a name="java-development-environment-ide"></a>

整合開發環境 (IDE) 提供可加速應用程式開發的各種功能。若您尚未使用 IDE 進行 Java 開發，請嘗試 Eclipse 和 IntelliJ，看哪個更適合您。
+  [安裝 Eclipse IDE for Java EE Developers](https://www.eclipse.org/downloads/) (Java EE 開發人員專用 Eclipse IDE) 
+  [安裝 IntelliJ](https://www.jetbrains.com/idea/) 

IDE 可能會於專案資料夾新增您不希望遞交給來源控制的檔案。欲避免將這些檔案遞交給來源控制，請使用 `.gitignore` 或等同來源控制工具的功能。

若您只想開始編碼且不需要 IDE 的所有功能，請考慮[安裝 Sublime Text](http://www.sublimetext.com/)。

**注意**  
在 2023 年 5 月 31 日， [AWS Toolkit for Eclipse](https://docs.aws.amazon.com//toolkit-for-eclipse/v1/user-guide/welcome.html)已達到生命週期結束，不再受到 支援 AWS。如需 生命週期結束的其他詳細資訊 AWS Toolkit for Eclipse，請參閱 AWS Toolkit for Eclipse GitHub 儲存庫上的 [README.md](https://github.com/aws/aws-toolkit-eclipse) 檔案。

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

本節提供額外的應用程式和教學課程。本主題稍早的 [適用於 Java 的 QuickStart ](java-quickstart.md)和 [Tomcat 上的適用於 Java 的 QuickStart ](tomcat-quickstart.md)主題會逐步引導您使用 EB CLI 啟動範例 Java 應用程式。

若要開始使用 Java 應用程式 AWS Elastic Beanstalk，您只需要上傳應用程式[原始碼套件](applications-sourcebundle.md)做為第一個應用程式版本，並部署到環境。當您建立環境時，Elastic Beanstalk 會設定所有需要的 AWS 資源，以執行可擴展的 Web 應用程式。

## 使用範例 Java 應用程式來啟動環境
<a name="java-getstarted-samples"></a>

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

這些單頁範例的程式碼，和您未提供自己的原始碼即建立環境時所得到的相同。GitHub 上託管了更為複雜的範例，這些範例可能需要先行編譯或建置，才能部署到 Elastic Beanstalk 環境。

 


**範例**  

|  名稱  |  支援的版本  |  環境類型  |  來源  |  描述  | 
| --- | --- | --- | --- | --- | 
|  Tomcat (單頁)  |  所有 *Tomcat with Corretto* 平台分支  |  Web 伺服器 工作者  |   [tomcat.zip](samples/tomcat.zip)   |  Tomcat Web 應用程式，包含設定要在網站根目錄顯示的單一頁面 (`index.jsp`)。 針對[工作者環境](using-features-managing-env-tiers.md)，此範例包含了 `cron.yaml` 檔案，其中設定了排程的任務，每分鐘呼叫 `scheduled.jsp` 一次。當 `scheduled.jsp` 受到呼叫時，會寫入位於 `/tmp/sample-app.log` 的日誌檔案。最後，`.ebextensions` 中包含了組態檔案，該檔案會在您請求環境日誌時，將日誌從 `/tmp/` 複製到 Elastic Beanstalk 所讀取的位置。 如果您在執行此範例的環境中[啟用 X-Ray 整合](environment-configuration-debugging.md)功能，則此應用程式會顯示關於 X-Ray 的其他內容，並提供選項，來產生可在 X-Ray 主控台中檢視的除錯資訊。  | 
|  Corretto (單頁)  |  Corretto 11 Corretto 8  |  Web 伺服器  |  [corretto.zip](samples/corretto.zip)  |  包含 `Buildfile` 與 `Procfile` 組態檔案的 Corretto 應用程式。 如果您在執行此範例的環境中[啟用 X-Ray 整合](environment-configuration-debugging.md)功能，則此應用程式會顯示關於 X-Ray 的其他內容，並提供選項，來產生可在 X-Ray 主控台中檢視的除錯資訊。  | 
|  Scorekeep  | Java 8 | Web 伺服器 | [複製 GitHub.com 的儲存庫](https://github.com/awslabs/eb-java-scorekeep) |  *Scorekeep* 是一種 RESTful web API，使用 Spring 架構來提供界面，此界面可用來建立和管理使用者、工作階段與遊戲。此 API 套裝隨附 Angular 1.5 Web 應用程式，這個應用程式可透過 HTTP 使用此 API。 此應用程式使用 Java SE 平台的功能，來下載相依項目和建置啟動執行個體，將原始碼套件的檔案大小減到最小。此應用程式亦包含 nginx 組態檔案，可覆寫預設組態，藉由代理的連接埠 80 供前端 Web 應用程式靜態使用，而路由則會要求 `/api` 底下運作於 `localhost:5000` 的 API 的路徑。 Scorekeep 也包含了 `xray` 的分支，此分支顯示如何備妥 Java 應用程式以搭配 AWS X-Ray使用。它顯示使用 servlet 篩選條件來檢測傳入的 HTTP 請求、自動和手動 AWS SDK 用戶端檢測、記錄器組態，以及檢測傳出的 HTTP 請求和 SQL 用戶端。 請參閱讀我檔案取得相關說明，或使用 [AWS X-Ray 入門教學](https://docs.aws.amazon.com/xray/latest/devguide/xray-gettingstarted.html)嘗試搭配應用程式和 X-Ray。  | 
|  Does it Have Snakes?  | Tomcat 8 搭配 Java 8 | Web 伺服器 | [複製 GitHub.com 的儲存庫](https://github.com/awslabs/eb-tomcat-snakes) |  *Does it Have Snakes?* 是一種 Tomcat Web 應用程式，會針對 Elastic Beanstalk 組態檔案、Amazon RDS、JDBC、PostgreSQL、Servlet、JSP、Simple Tag Support、標記檔案、Log4J、Bootstrap 與 Jackson，顯示使用的狀況。 此專案的原始程式碼包含了最低程度的建置指令碼，這些指令碼會將 Servlet 和模型編譯為類別檔案，並將所需的檔案封裝為 Web 封存檔案，此等封裝檔案可以部署到 Elastic Beanstalk 環境。如需完整說明，請參閱專案儲存庫中的 readme 檔案。  | 
| Locust Load Generator | Java 8 | Web 伺服器 | [複製 GitHub.com 的儲存庫](https://github.com/awslabs/eb-locustio-sample) |  Web 應用程式，您可以用來針對不同 Elastic Beanstalk 環境中執行的另一個 Web 應用程式，進行負載測試。顯示 `Buildfile` 和 `Procfile` 檔案、DynamoDB 與 [Locust](http://locust.io/) 的使用狀況，Locust 是一種開放原始碼的負載測試工具。  | 

下載任一範例應用程式，並依下列步驟將其部署至 Elastic Beanstalk：

**使用 應用程式啟動環境 （主控台）**

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

1. 在導覽窗格中，選擇 **Applications (應用程式)**。在清單中選取現有的應用程式。您也可以依照 中的指示，選擇建立一個[管理 應用程式](applications.md)。

1. 在應用程式概觀頁面上，選擇**建立環境**。

   這會啟動 **Create environment** (建立環境) 精靈。精靈提供一組建立新環境的步驟。

1. 針對**環境層**，選擇 **Web 伺服器環境**或**工作者環境**[環境層](concepts.md#concepts-tier)。建立後您即無法變更環境層。
**注意**  
[Windows Server 平台上的 .NET](create_deploy_NET.md) 不支援工作者環境層。

   **應用程式資訊**欄位預設為根據您先前選擇的應用程式。

   在**環境資訊**中，根據應用程式**名稱將環境**名稱分組為預設值。如果您偏好不同的環境名稱，您可以在欄位中輸入另一個值。您可以選擇輸入**網域名稱**，否則 Elastic Beanstalk 會自動產生值。您也可以選擇性地輸入**環境描述。**

1. 在 **Platform (平台)**，選取符合您應用程式所使用語言的平台和平台分支。
**注意**  
Elastic Beanstalk 支援所列出大多數平台的多個[版本](concepts.platforms.md)。根據預設，主控台會針對您選擇的平台和平台分支，選取建議的版本。如果您的應用程式需要不同的版本，您可以在這裡選取。如需支援的平台版本的相關詳細資訊，請參閱 [支援 Elastic Beanstalk 的平台](concepts.platforms.md)。

1. 對於**應用程式碼**，您有幾個選擇可以繼續。
   + 若要啟動預設範例應用程式而不提供原始碼，請選擇**範例應用程式**。此動作會選擇 Elastic Beanstalk 為您先前選取的平台提供的單一頁面應用程式。
   + 如果您從本指南下載範例應用程式，或擁有自己的應用程式原始碼，請執行下列步驟。

     1. 選取**上傳您的程式碼**。

     1. 接著選擇**本機檔案**，然後在**上傳應用程式**下，選擇**選擇檔案**。

     1. 用戶端機器的作業系統會顯示 界面，以選取您下載的本機檔案。選取原始碼套件檔案並繼續。

1. 您對**預設**集的選擇取決於您對環境的用途。
   + 如果您要建立範例環境來了解 Elastic Beanstalk 或開發環境，請選擇**單一執行個體 （符合免費方案資格）**。
   + 如果您要建立生產環境或環境以進一步了解負載平衡，請選擇其中一個**高可用性**選項。

1. 選擇**下一步**。

**設定服務存取**  
接下來，您需要兩個角色。*服務角色*可讓 Elastic Beanstalk 監控您的 EC2 執行個體，並升級您環境的平台。*EC2 執行個體描述*檔角色允許寫入日誌和與其他 服務互動等任務。

**建立或選取服務角色**

1. 如果您先前已建立**服務角色**，並想要選擇現有的角色，請從**服務角色**下拉式清單中選取值，然後略過這些步驟的其餘部分來建立服務角色。

1. 如果您沒有看到針對**服務角色**列出的任何值，或者您想要建立新的值，請繼續執行後續步驟。

1. 針對**服務角色**，選擇**建立角色**。

1. 針對**信任的實體類型**，請選擇 **AWS 服務**。

1. 針對**使用案例**，選擇 **Elastic Beanstalk – 環境**。

1. 選擇**下一步**。

1. 確認**許可政策**包含下列項目，然後選擇**下一步**：
   + `AWSElasticBeanstalkEnhancedHealth`
   + `AWSElasticBeanstalkManagedUpdatesCustomerRolePolicy`

1. 選擇建**立角色**。

1. 返回**設定服務存取**索引標籤，重新整理清單，然後選取新建立的服務角色。

**建立或選取 EC2 執行個體描述檔**

1. 如果您先前已建立 **EC2 執行個體描述檔**，並想要選擇現有的描述檔，請從 **EC2 執行個體描述檔**下拉式清單中選取值，然後略過這些步驟的其餘部分來建立 EC2 執行個體描述檔。

1. 如果您沒有看到 **EC2 執行個體描述檔**列出的任何值，或想要建立新的值，請繼續執行後續步驟。

1. 選擇建**立角色**。

1. 針對**信任的實體類型**，請選擇 **AWS 服務**。

1. 針對**使用案例**，選擇** Elastic Beanstalk – 運算**。

1. 選擇**下一步**。

1. 確認**許可政策**包含下列項目，然後選擇**下一步**：
   + `AWSElasticBeanstalkWebTier`
   + `AWSElasticBeanstalkWorkerTier`
   + `AWSElasticBeanstalkMulticontainerDocker`

1. 選擇建**立角色**。

1. 返回**設定服務存取**索引標籤，重新整理清單，然後選取新建立的 EC2 執行個體描述檔。

**完成設定和建立您的應用程式**

1. （選用） 如果您先前已建立 EC2 金鑰對，您可以從 **EC2 金鑰對**欄位下拉式清單中選取它。您可以使用它安全地登入 Elastic Beanstalk 為您的應用程式佈建的 Amazon EC2 執行個體。如果您略過此步驟，您可以隨時在環境建立後建立和指派 EC2 金鑰對。如需詳細資訊，請參閱[EC2 key pair (EC2 金鑰對)](using-features.managing.security.md#using-features.managing.security.keypair)。

1. 在 **Configure service access** (設定服務存取)頁面上選擇 **Skip to Review** (略過以檢閱)。

1. **Review** (檢閱)頁面會顯示您所有選擇的摘要。

   若要進一步自訂您的環境，請選擇步驟旁的 **Edit** (編輯)，其中包含您想要設定的任何項目。下列選項僅能於環境建立期間進行設定：
   + 環境名稱
   + 網域名稱
   + 平台版本
   + 處理器
   + 負載平衡器類型
   + 層

   下列設定可於環境建立後變更，但需要佈建新的執行個體或其他資源，且套用時間可能較長：
   + 執行個體類型、根磁碟區、金鑰對和 AWS Identity and Access Management (IAM) 角色
   + 內部 Amazon RDS 資料庫
   + VPC

   如需所有可用設定的詳細資訊，請參閱[建立新的環境精靈](environments-create-wizard.md)。

1. 選擇頁面底部的 **Submit** (提交)，以將建立的新環境初始化。

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

在您擁有執行應用程式的環境後，可以隨時[部署應用程式的新版本](using-features.deploy-existing-version.md)或完全不同的應用程式。部署新的應用程式版本非常快速，因無須佈建或重新啟動 EC2 執行個體。

在您部署好一兩個範例應用程式，並準備好開始在本機上開發和執行 Java 應用程式之後，請參閱[下一節](java-development-environment.md)的內容，利用您將會用到的所有工具和程式庫，來設定 Java 開發環境。

# 使用 Elastic Beanstalk Tomcat 平台
<a name="java-tomcat-platform"></a>

本主題說明如何設定、建置和執行在 Elastic Beanstalk Tomcat 平台上執行的 Java 應用程式。

 AWS Elastic Beanstalk Tomcat 平台是一組適用於 Java Web 應用程式的[平台版本](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.java)，可在 Tomcat Web 容器中執行。Tomcat 會在 nginx 代理服務器後面執行。每個平台分支對應至 Tomcat 的主要版本。

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

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

Elastic Beanstalk Tomcat 平台包含了反向代理程式，可將請求轉送給您的應用程式。您可使用[組態選項](#java-tomcat-namespaces)來設定代理伺服器，從您原始程式碼中的資料夾提供靜態資產，以減輕應用程式的負擔。在進階的使用情境中，您可以在您的原始碼套件中，[加入自己的 `.conf` 檔案](java-tomcat-proxy.md)，來擴展或完全覆寫掉 Elastic Beanstalk 的代理組態。

**注意**  
Elastic Beanstalk 支援 [nginx](https://www.nginx.com/) (預設值) 和 [Apache HTTP 伺服器](https://httpd.apache.org/)作為 Tomcat 平台上的代理伺服器。如果您的 Elastic Beanstalk Tomcat 環境使用 Amazon Linux AMI 平台分支 (Amazon Linux 2 之前)，您也可以選擇使用 [Apache HTTP 伺服器版本 2.2](https://httpd.apache.org/docs/2.2/)。在這些較舊平台分支上會預設使用 Apache 最新版。  
 在 [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)。

您必須使用特定的架構，來將 Java 應用程式的套件，打包為 Web 應用程式封裝 (WAR) 格式的檔案。關於所需的架構，以及該架構與您專案目錄架構之間的關係，詳細資訊請參閱[建構您的專案資料夾](java-tomcat-platform-directorystructure.md)。

若要在同一個 Web 伺服器上執行多個應用程式，您可以[將多個 WAR 檔案打包](java-tomcat-multiple-war-files.md)為單一原始碼套件。在包含多個 WAR 原始碼的套件中，取決於 WAR 的名稱，每個應用程式會在根路徑 (`ROOT.war` 在 `myapp.elasticbeanstalk.com/` 中執行) 或根路徑之下直屬的路徑 (`app2.war` 在 `myapp.elasticbeanstalk.com/app2/` 中執行) 執行。在單一 WAR 原始碼套件中，應用程式永遠會在根路徑執行。

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

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

**Topics**
+ [

## 設定您的 Tomcat 環境
](#java-tomcat-options)
+ [

## Tomcat 組態命名空間
](#java-tomcat-namespaces)
+ [

# 綁定多個用於 Tomcat 環境的 WAR 檔案
](java-tomcat-multiple-war-files.md)
+ [

# 建構您的專案資料夾
](java-tomcat-platform-directorystructure.md)
+ [

# 設定代理伺服器
](java-tomcat-proxy.md)

## 設定您的 Tomcat 環境
<a name="java-tomcat-options"></a>

Elastic Beanstalk Tomcat 平台除了所有平台皆有的標準選項外，還提供幾個平台特定的選項。這些選項可讓您設定在您環境 web 伺服器上執行的 Java 虛擬機器 (JVM)，和定義系統屬性，來為應用程式提供資訊組態字串。

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

**在 Elastic Beanstalk 主控台中設定您的 Tomcat 環境**

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

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

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

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

### 容器選項
<a name="java-tomcat-options-container"></a>

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

### JVM 容器選項
<a name="java-tomcat-options-jvm"></a>

Java 虛擬機器 (JVM) 中的堆積大小，決定了在*[記憶體回收](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/introduction.html)*發生之前，您的應用程式可以在記憶體中建立多少物件。您可以修改**初始 JVM 堆積大小** (`-Xms option`) 和 **JVM 堆積大小上限** (`-Xmx` 選項)。較大的初始堆積大小可在記憶體回收進行之前，讓更多的物件能夠建立。但這也表示記憶體回收器會花費更多的時間來壓縮堆疊。堆積大小的上限，指定了在繁重的作業進行期間擴充堆疊時，JVM 可以分配的最大記憶體容量。

**注意**  
可用的記憶體取決於 Amazon EC2 執行個體類型。如需可供您 Elastic Beanstalk 環境使用之 EC2 執行個體類型的詳細資訊，請參閱*適用於 Linux 執行個體的 Amazon Elastic Compute Cloud 使用者指南*中的[執行個體類型](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html)。

*永久保存區*是 JVM 堆積的一個區段，用來儲存類別定義與相關的中繼資料。若要修改永久保存區的大小，請在 **JVM 永久保存區大小上限** (`-XX:MaxPermSize`) 選項中輸入新的大小。此設定僅適用於 Java 7 和較舊的版本。此選項已在 JDK 8 中棄用，並由 **MaxMetaspace Size** (`-XX:MaxMetaspaceSize`) 選項取代。

**重要**  
JDK 17 移除了對 Java `-XX:MaxPermSize` 選項的支援。將此選項與具有 Corretto 17 的 Elastic Beanstalk 平台分支上執行的環境搭配使用將導致錯誤。Elastic Beanstalk 於 [2023 年 7 月 13 日](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2023-07-13-al2023.html)發布了第一個執行 Tomcat 與 Corretto 17 的平台分支。  
如需詳細資訊，請參閱下列資源。  
Oracle Java 文件網站：[已刪除 Java 選項](https://docs.oracle.com/en/java/javase/17/docs/specs/man/java.html#removed-java-options) 
Oracle Java 文件網站：[其他考量事項](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/considerations.html)中的*類別中繼資料*區段

如需有關 Elastic Beanstalk 平台及其元件的詳細資訊，請參閱《AWS Elastic Beanstalk 平台指南》**中[支援的平台](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html)。

### 日誌選項
<a name="java-tomcat-options-logs"></a>

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

### 靜態檔案
<a name="java-tomcat-options-staticfiles"></a>

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

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

### 環境屬性
<a name="java-tomcat-options-properties"></a>

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

Tomcat 平台會針對 Tomcat 環境，定義名為 `JDBC_CONNECTION_STRING` 的佔位符屬性，用來將連線字串傳遞到外部資料庫。

**注意**  
如果您將 RDS 資料庫執行個體連接到您的環境，請從 Elastic Beanstalk 提供的 Amazon Relational Database Service (Amazon RDS) 環境屬性動態建構 JDBC 連線字串。對於非使用 Elastic Beanstalk 佈建的資料庫執行個體，請只使用 JDBC\$1CONNECTION\$1STRING。  
關於使用 Amazon RDS 與您的 Java 應用程式的詳細資訊，請參閱[將 Amazon RDS 資料庫執行個體新增至 Java Elastic Beanstalk 環境](java-rds.md)。

對於 2[025 年 3 月 26](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2025-03-26-windows.html) 日之前發行的 Tomcat 平台版本，可以使用 存取環境變數`System.getProperty()`。例如，您可以從具有下列程式碼的變數讀取名為 `API_ENDPOINT`的屬性。

```
String endpoint = System.getProperty("API_ENDPOINT");
```

2[025 年 3 月 26](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2025-03-26-windows.html) 日當天或之後發行的 Tomcat 平台版本，也可以用來`System.getenv`存取純文字環境變數。您可以繼續使用 `System.getProperty` 來存取純文字環境變數。不過，[存放為秘密的環境變數](AWSHowTo.secrets.env-vars.md)只能使用 `System.getenv`。例如，您可以使用`API_KEY`下列程式碼讀取名為 的環境變數。

```
String apiKey = System.getenv("API_KEY");
```

**重要**  
在 [2025 年 3 月 26](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2025-03-26-windows.html) 日當天或之後發行的 Tomcat 平台版本中，新增環境變數的`System.getenv()`存取權可能會導致應用程式中的意外行為，這些行為將環境變數優先於 Java 系統屬性，或從 明確切換`System.getProperty()`到 `System.getenv()`。  
由於系統屬性 （透過命令列傳遞） 需要 Shell 逸出特殊字元，而環境變數則不需要，因此使用環境變數而非 Java 系統屬性時，可能會以不同的方式解析值。  
如果您的應用程式受到影響，請考慮：  
使用 時，從您的環境屬性值移除逸出字元 `System.getenv()`
設定您的應用程式以明確使用 `System.getProperty()`
升級時徹底測試您的應用程式，以確保一致的行為

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

## Tomcat 組態命名空間
<a name="java-tomcat-namespaces"></a>

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

除了[適用於所有 Elastic Beanstalk 環境的支援選項](command-options-general.md)之外，Tomcat 也支援使用下列命名空間的選項：
+ `aws:elasticbeanstalk:container:tomcat:jvmoptions` - 修改 JVM 設定。使用此命名空間的選項，對應管理主控台中的選項，如下所示：
  + `Xms` - **JVM command line options (JVM 命令列選項**
  + `JVM Options` - **JVM command line options (JVM 命令列選項**
+ `aws:elasticbeanstalk:environment:proxy` - 選擇環境的代理伺服器。

下列的組態檔案範例展示了 Tomcat 特定組態選項的使用。

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

```
option_settings:
  aws:elasticbeanstalk:container:tomcat:jvmoptions:
    Xms: 512m
    JVM Options: '-Xmn128m'
  aws:elasticbeanstalk:application:environment:
    API_ENDPOINT: mywebapi.zkpexsjtmd.us-west-2.elasticbeanstalk.com
  aws:elasticbeanstalk:environment:proxy:
    ProxyServer: apache
```

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

## Amazon Linux AMI (Amazon Linux 2 之前) Tomcat 平台
<a name="tomcat.alami"></a>

如果您的 Elastic Beanstalk Tomcat 環境使用 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)。

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

Tomcat Amazon Linux AMI 平台在下列命名空間中支援其他選項：
+ `aws:elasticbeanstalk:container:tomcat:jvmoptions` - 除了此命名空間之前在此頁面上提到的選項之外，較舊的 Amazon Linux AMI 平台版本也支援：
  + `XX:MaxPermSize` - **Maximum JVM permanent generation size (JVM 永久保存區大小上限**
+ `aws:elasticbeanstalk:environment:proxy` - 除了選擇代理伺服器之外，還會設定回應壓縮。

下列組態檔案範例展示了使用代理命名空間組態選項。

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

```
option_settings:
  aws:elasticbeanstalk:environment:proxy:
    GzipCompression: 'true'
    ProxyServer: nginx
```

### 包括 Elastic Beanstalk 組態檔案 — Amazon Linux AMI (AL1)
<a name="java-tomcat-ebextensions"></a>

若要部署 `.ebextensions` 設定檔，將其納入您的應用程式原始程式碼。對於單一應用程式，執行下列命令，將 `.ebextensions` 新增至壓縮的 WAR 檔案：

**Example**  

```
zip -ur your_application.war .ebextensions
```

有關需要多個 WAR 檔案的應用程式，請參閱 [綁定多個用於 Tomcat 環境的 WAR 檔案](java-tomcat-multiple-war-files.md) 的詳細說明。

# 綁定多個用於 Tomcat 環境的 WAR 檔案
<a name="java-tomcat-multiple-war-files"></a>

若您的 Web 應用程式包含多個 Web 應用程式元件，您可在單一環境執行元件，而非針對各個元件執行不同環境，藉此簡化部署並降低作業成本。對於不需要大量資源的輕量型應用程式或開發及測試環境而言，本策略十分有效。

欲將多個 Web 應用程式部署至您的環境，請將各個元件 Web 應用程式封存檔 (WAR) 檔案結合至單一[原始碼套件](applications-sourcebundle.md)。

欲建立內含多個 WAR 檔案的應用程式原始碼套件，請以下列結構整理 WAR 檔案。

```
MyApplication.zip
├── .ebextensions
├── .platform
├── foo.war
├── bar.war
└── ROOT.war
```

當您將包含多個 WAR 檔案的原始碼套件部署到 AWS Elastic Beanstalk 環境時，可以從根網域名稱的不同路徑存取每個應用程式。上述範例包含三個應用程式：`foo`、`bar` 及 `ROOT`。`ROOT.war` 為特殊檔案名稱，可指示 Elastic Beanstalk 於該根網域執行該應用程式，讓三個應用程式可於 `http://MyApplication.elasticbeanstalk.com/foo`、`http://MyApplication.elasticbeanstalk.com/bar` 及 `http://MyApplication.elasticbeanstalk.com` 使用。

原始碼套件可以包括 WAR 文件，一個選用 `.ebextensions` 資料夾和一個選用 `.platform` 資料 夾。如需這些選用組態資料夾的詳細資訊，請參閱 [擴充 Elastic Beanstalk Linux 平台](platforms-linux-extend.md)。

**啟動環境 (主控台)**

1. 透過此一預設連結來開啟 Elastic Beanstalk 主控台：[console.aws.amazon.com/elasticbeanstalk/home\$1/newApplication?applicationName=tutorials&environmentType=LoadBalanced](https://console.aws.amazon.com/elasticbeanstalk/home#/newApplication?applicationName=tutorials&environmentType=LoadBalanced)

1. 在 **Platform** (平台)，選取符合您應用程式所使用語言的平台和平台分支，或針對以容器為基礎的應用程式選取 Docker 平台。

1. 在 **Application code (應用程式的程式碼)**，選擇 **Upload your code (上傳您的程式碼)**。

1. 選擇 **Local file (本機檔案)**，選擇 **Choose file (選擇檔案)**，然後開啟原始碼套件。

1. 選擇 **Review and launch (檢閱和啟動)**。

1. 檢閱可用的設定，然後選擇 **Create app (建立應用程式)**。

如需建立原始碼套件的資訊，請參閱 [建立 Elastic Beanstalk 應用程式原始碼套件](applications-sourcebundle.md)。

# 建構您的專案資料夾
<a name="java-tomcat-platform-directorystructure"></a>

若要在部署到 Tomcat 伺服器時能夠運作，編譯的 Java Platform Enterprise Edition (*Java EE*) web 應用程式封存檔 (WAR 檔案) 必須根據特定[準則](https://docs.oracle.com/javaee/7/tutorial/packaging003.htm)來建構。您的專案目錄不需要滿足相同的標準，但最好也採用相同的結構以簡化編譯和封裝。在建置專案資料夾時，採用與 WAR 檔案內容相同的架構，也有助於您了解檔案彼此的關聯，和檔案在 Web 伺服器上的運作方式。

在下列建議的階層中，會將 web 應用程式的原始程式碼放置於 `src` 目錄中，來與建置指令碼和其所產生的 WAR 檔案隔離。

```
~/workspace/my-app/
|-- build.sh            - Build script that compiles classes and creates a WAR
|-- README.MD           - Readme file with information about your project, notes
|-- ROOT.war            - Source bundle artifact created by build.sh
`-- src                 - Source code folder
    |-- WEB-INF         - Folder for private supporting files
    |   |-- classes     - Compiled classes
    |   |-- lib         - JAR libraries
    |   |-- tags        - Tag files
    |   |-- tlds        - Tag Library Descriptor files
    |   `-- web.xml     - Deployment Descriptor
    |-- com             - Uncompiled classes
    |-- css             - Style sheets
    |-- images          - Image files
    |-- js              - JavaScript files
    `-- default.jsp     - JSP (JavaServer Pages) webpage
```

`src` 資料夾的內容符合您將封裝和部署到伺服器的內容，不過未包含 `com` 資料夾。此 `com` 資料夾包含您未編譯的類別 (`.java` 檔案)。這些需要被編譯，並放到您的應用程式程式碼可以存取的 `WEB-INF/classes` 目錄中。

`WEB-INF` 目錄中包含不會在 Web 伺服器上公開提供的程式碼與組態。位於來源目錄根的其他資料夾 (`css`、`images` 與 `js`)，則會於 web 伺服器上的對應路徑公開提供。

下列的範例與先前的專案目錄相同，但包含了更多的檔案和子目錄。此範例專案包含簡單的標籤、模型和支援類別，以及 `record` 資源的 Java Server Pages (JSP) 檔案。此範例還包含 [Bootstrap](http://getbootstrap.com/) 的樣式表和 JavaScript、預設的 JSP 檔案，以及 404 錯誤的錯誤訊息頁面。

`WEB-INF/lib` 包含了 Java Archive (JAR) 檔案，內有適用於 PostgreSQL 的 Java Database Connectivity (JDBC) 驅動程式。`WEB-INF/classes` 為空，因為類別檔案尚未編譯。

```
~/workspace/my-app/
|-- build.sh
|-- README.MD
|-- ROOT.war
`-- src
    |-- WEB-INF
    |   |-- classes
    |   |-- lib
    |   |   `-- postgresql-9.4-1201.jdbc4.jar
    |   |-- tags
    |   |   `-- header.tag
    |   |-- tlds
    |   |   `-- records.tld
    |   `-- web.xml
    |-- com
    |   `-- myapp
    |       |-- model
    |       |   `-- Record.java
    |       `-- web
    |           `-- ListRecords.java
    |-- css
    |   |-- bootstrap.min.css
    |   `-- myapp.css
    |-- images
    |   `-- myapp.png
    |-- js
    |   `-- bootstrap.min.js
    |-- 404.jsp
    |-- default.jsp
    `-- records.jsp
```

## 使用 Shell 指令碼來建置 WAR 檔案
<a name="java-tomcat-platform-directorystructure-building"></a>

`build.sh` 是極為簡單的 shell 指令碼，可編譯 Java 類別、建構 WAR 檔案，以及將檔案複製到 Tomcat 的 `webapps` 目錄來進行本機測試。

```
cd src
javac -d WEB-INF/classes com/myapp/model/Record.java
javac -classpath WEB-INF/lib/*:WEB-INF/classes -d WEB-INF/classes com/myapp/model/Record.java
javac -classpath WEB-INF/lib/*:WEB-INF/classes -d WEB-INF/classes com/myapp/web/ListRecords.java

jar -cvf ROOT.war *.jsp images css js WEB-INF
cp ROOT.war /Library/Tomcat/webapps
mv ROOT.war ../
```

在 WAR 檔案中，會具有與先前範例的 `src` 目錄相同的架構 (不包括 `src/com` 資料夾)。`jar` 指令會自動建立 `META-INF/MANIFEST.MF` 檔案。

```
~/workspace/my-app/ROOT.war
|-- META-INF
|   `-- MANIFEST.MF
|-- WEB-INF
|   |-- classes
|   |   `-- com
|   |       `-- myapp
|   |           |-- model
|   |           |   `-- Records.class
|   |           `-- web
|   |               `-- ListRecords.class
|   |-- lib
|   |   `-- postgresql-9.4-1201.jdbc4.jar
|   |-- tags
|   |   `-- header.tag
|   |-- tlds
|   |   `-- records.tld
|   `-- web.xml
|-- css
|   |-- bootstrap.min.css
|   `-- myapp.css
|-- images
|   `-- myapp.png
|-- js
|   `-- bootstrap.min.js
|-- 404.jsp
|-- default.jsp
`-- records.jsp
```

## 使用 `.gitignore`
<a name="java-tomcat-platform-gitignore"></a>

為避免將編譯過的類別檔案和 WAR 檔案提交於您的 Git 儲存庫中，或是在執行 Git 指令時出現關於這些檔案的訊息，請將相關的檔案類別新增至專案資料夾中名為 `.gitignore` 的檔案內。

**\$1/workspace/myapp/.gitignore**

```
*.zip
*.class
```

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

Tomcat 平台使用 [nginx](https://www.nginx.com/) (預設值) 或 [Apache HTTP 伺服器](https://httpd.apache.org/)作為反向代理程式，來將執行個體上 80 連接埠所傳入的要求，轉傳給監聽 8080 埠的 Tomcat Web 容器。Elastic Beanstalk 提供了預設的代理組態，您可以加以擴展，或使用自己的組態將其完全覆寫。

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

## 在 Amazon Linux AMI (Amazon Linux 2 之前) Tomcat 平台上設定代理
<a name="java-tomcat-proxy.alami"></a>

如果您的 Elastic Beanstalk Tomcat 環境使用 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)。

### 為您的 Tomcat 環境選擇代理伺服器 — Amazon Linux AMI (AL1)
<a name="java-tomcat-proxy.alami"></a>

以 Amazon Linux AMI (Amazon Linux 2 之前) 為基礎的 Tomcat 平台版本預設會使用 [Apache 2.4](https://httpd.apache.org/docs/2.4/) 作為代理。您可以選擇使用 [Apache 2.2](https://httpd.apache.org/docs/2.2/) 或 [nginx](https://www.nginx.com/)，做法是將[組態檔案](ebextensions.md)包含在原始碼中。下列範例設定 Elastic Beanstalk 使用 nginx。

**Example .ebextensions/nginx-proxy.config**  

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

### 從 Apache 2.2 遷移到 Apache 2.4 — Amazon Linux AMI (AL1)
<a name="java-tomcat-proxy-apache-migrate"></a>

如果您的應用程式是針對 [Apache 2.2](https://httpd.apache.org/docs/2.2/) 開發，請讀取此部分以了解遷移到 [ Apache 2.4 ](https://httpd.apache.org/docs/2.4/) 相關資訊。

從 Tomcat 平台版本發行 3.0.0 組態入門，與 [Java 和更新於 2018 年 5 月 24 日的 Tomcat 平台](https://aws.amazon.com/releasenotes/release-aws-elastic-beanstalk-platform-update-for-the-java-with-tomcat-platform-on-may-24-2018/)一起發行，Apache 2.4 是 Tomcat 平台的預設 Proxy。Apache 2.4`.conf` 檔案大多數與 Apache 2.2 的舊版相容，但不是全部如此。Elastic Beanstalk 包含與每個 Apache 版本正常運作的預設 `.conf` 檔案。如果您的應用程式不自訂 Apache 的組態，如 [擴展和覆寫預設的 Apache 組態 — Amazon Linux AMI (AL1)](#java-tomcat-proxy-apache) 所述，遷移到 Apache 2.4 應該不會有任何問題。

如果您的應用程式擴展或覆寫 Apache 的組態，您可能需要做一些變更才能遷移到 Apache 2.4。如需詳細資訊，請參閱 *The Apache Software Foundation* 網站上的[從 2.2 升級到 2.4](https://httpd.apache.org/docs/current/upgrading.html)。關於成功地遷移到 Apache 2.4 之前的臨時測量，您可以選擇 Apache 2.2 與您的應用程式搭配使用，做法是將以下[組態檔案](ebextensions.md)納入原始碼。

**Example .ebextensions/apache-legacy-proxy.config**  

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

對於快速修正，您也可以選擇 Elastic Beanstalk 主控台的代理伺服器。

**在 Elastic Beanstalk 主控台中選擇您 Tomcat 環境的代理**

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

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

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

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

1. 對於 **Proxy server (代理伺服器)**，請選擇 `Apache 2.2 (deprecated)`。

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

![\[在 Elastic Beanstalk 主控台的軟體組態類別中選擇 Tomcat 環境的代理程式\]](http://docs.aws.amazon.com/zh_tw/elasticbeanstalk/latest/dg/images/java-tomcat-proxy-selection.png)


### 擴展和覆寫預設的 Apache 組態 — Amazon Linux AMI (AL1)
<a name="java-tomcat-proxy-apache"></a>

您可以擴展 Elastic Beanstalk 預設 Apache 組態與您的其他組態檔案。或者，您可以完全覆寫 Elastic Beanstalk 預設 Apache 組態。

**注意**  
所有 Amazon Linux 2 平台皆支援統一的代理組態功能。如需在執行 Amazon Linux 2 的 Tomcat 平台版本上設定代理伺服器的詳細資訊，請參閱 [反向代理組態](platforms-linux-extend.proxy.md)。
如果您要將 Elastic Beanstalk 應用程式遷移至 Amazon Linux 2 平台，請務必同時閱讀 [將您的 Elastic Beanstalk Linux 應用程式遷移到 Amazon Linux 2023 或 Amazon Linux 2](using-features.migration-al.md) 中的資訊。

若要擴展 Elastic Beanstalk 預設 Apache 組態，請將 `.conf` 組態檔案加入您應用程式原始碼套件中名為 `.ebextensions/httpd/conf.d` 的資料夾。Elastic Beanstalk Apache 組態會自動在此資料夾中加入 `.conf` 檔案。

```
~/workspace/my-app/
|-- .ebextensions
|   -- httpd
|      -- conf.d
|         -- myconf.conf
|         -- ssl.conf
-- index.jsp
```

例如，下列 Apache 2.4 組態會在 5000 埠上新增接聽程式。

**Example .ebextensions/httpd/conf.d/port5000.conf**  

```
listen 5000
<VirtualHost *:5000>
  <Proxy *>
    Require all granted
  </Proxy>
  ProxyPass / http://localhost:8080/ retry=0
  ProxyPassReverse / http://localhost:8080/
  ProxyPreserveHost on

  ErrorLog /var/log/httpd/elasticbeanstalk-error_log
</VirtualHost>
```

若要完全覆寫 Elastic Beanstalk 預設 Apache 組態，請在 `.ebextensions/httpd/conf/httpd.conf` 的原始碼套件中加入組態。

```
~/workspace/my-app/
|-- .ebextensions
|   `-- httpd
|       `-- conf
|           `-- httpd.conf
`-- index.jsp
```

如果您覆寫了 Elastic Beanstalk Apache 組態，請在 `httpd.conf`中加入下列幾行程式，以提取 [Elastic Beanstalk 中的增強型運作狀態報告和監控](health-enhanced.md) 的 Elastic Beanstalk 組態、回應壓縮和靜態檔案。

```
IncludeOptional conf.d/*.conf
IncludeOptional conf.d/elasticbeanstalk/*.conf
```

如果您的環境中使用 Apache 2.2 做為其 Proxy，請將 `IncludeOptional` 指令取代為 `Include`。如需有關兩個 Apache 版本的這兩個指令行為的詳細資訊，請參閱[包含在 Apache 2.4 中](https://httpd.apache.org/docs/2.4/mod/core.html#include)、[IncludeOptional 在 Apache 2.4 中](https://httpd.apache.org/docs/2.4/mod/core.html#includeoptional)和[包含在 Apache 2.2 中](https://httpd.apache.org/docs/2.2/mod/core.html#include)。

**注意**  
若要覆寫 80 埠的預設接聽程式，請在 `00_application.conf` 中加入名為 `.ebextensions/httpd/conf.d/elasticbeanstalk/` 的檔案，以覆寫 Elastic Beanstalk 的組態。

如需運作範例，請參見位於您環境執行個體上的 Elastic Beanstalk 預設組態檔案 (`/etc/httpd/conf/httpd.conf`)。在部署作業進行期間，您原始碼套件 `.ebextensions/httpd` 資料夾中的所有檔案，都會複製到 `/etc/httpd`。

### 擴展預設的 nginx 組態 — Amazon Linux AMI (AL1)
<a name="java-tomcat-proxy-nginx"></a>

若要擴展 Elastic Beanstalk 的預設 nginx 組態，請將 `.conf` 組態檔案加進您應用程式原始碼套件中名為 `.ebextensions/nginx/conf.d/` 的資料夾。Elastic Beanstalk nginx 組態會自動在此資料夾中加入 `.conf` 檔案。

```
~/workspace/my-app/
|-- .ebextensions
|   `-- nginx
|       `-- conf.d
|           |-- elasticbeanstalk
|           |   `-- my-server-conf.conf
|           `-- my-http-conf.conf
`-- index.jsp
```

在預設組態的 `conf.d` 區塊中，會包含 `http` 資料夾中具備 .conf 副檔名的檔案。在 `conf.d/elasticbeanstalk` 區塊的 `server` 區塊中，會包含 `http` 資料夾中的檔案。

若要完全覆寫 Elastic Beanstalk 預設 nginx 組態，請在您原始碼套件的 `.ebextensions/nginx/nginx.conf` 中加入組態。

```
~/workspace/my-app/
|-- .ebextensions
|   `-- nginx
|       `-- nginx.conf
`-- index.jsp
```

**備註**  
如果覆寫 Elastic Beanstalk nginx 組態，請在組態的 `server` 區塊中加入下列幾行程式，以納入 80 埠接聽程式的 Elastic Beanstalk 組態、回應內容壓縮和靜態檔案。  

  ```
   include conf.d/elasticbeanstalk/*.conf;
  ```
若要覆寫 80 埠的預設接聽程式，請在 `00_application.conf` 中加入名為 `.ebextensions/nginx/conf.d/elasticbeanstalk/` 的檔案，以覆寫 Elastic Beanstalk 的組態。
另外也請在您組態的 `http` 區塊中，加入下列幾行程式，以提取 [Elastic Beanstalk 中的增強型運作狀態報告和監控](health-enhanced.md) 的 Elastic Beanstalk 組態和記錄。  

  ```
      include       conf.d/*.conf;
  ```

如需運作範例，請參見位於您環境執行個體上的 Elastic Beanstalk 預設組態檔案 (`/etc/nginx/nginx.conf`)。在部署作業進行期間，您原始碼套件 `.ebextensions/nginx` 資料夾中的所有檔案，都會複製到 `/etc/nginx`。

# 使用 Elastic Beanstalk Java SE 平台
<a name="java-se-platform"></a>

本主題說明如何設定、建置和執行在 Java SE 平台上執行的 AWS Elastic Beanstalk Java 應用程式。

Elastic Beanstalk Java SE 平台是一組適用於 Java Web 應用程式的[平台版本](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.javase)，可以從編譯的 JAR 檔案自行執行。您可於本機編譯應用程式，或搭配建置指令碼上傳原始碼，藉此在執行個體上進行編譯。Java SE 平台版本會分組為平台分支，每個分支對應至 Java 的主要版本。

**注意**  
Elastic Beanstalk 不會剖析應用程式的 JAR 檔案。請將 Elastic Beanstalk 需要的檔案保存在 JAR 檔案外面。例如，將[工作者環境](using-features-managing-env-tiers.md)的 `cron.yaml` 檔案包含在應用程式原始碼套件的根目錄 (在 JAR 檔案旁邊)。

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

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

Elastic Beanstalk Java SE 平台內含可做為反向代理程式的 [nginx](https://www.nginx.com/) 伺服器，處理快取靜態內容並將請求傳送至您的應用程式。平台提供了組態選項來設定代理伺服器，從您原始程式碼中的資料夾提供靜態資產，以減輕應用程式的負擔。在進階的使用情境中，您可以在您的原始碼套件中，[加入自己的 .conf 檔案](java-se-nginx.md)，來擴展或完全覆寫掉 Elastic Beanstalk 的代理組態。

如果您只為應用程式來源提供單一 JAR 檔案 (自行提供，而非在原始碼套件中)，Elastic Beanstalk 會將 JAR 檔案重新命名為 `application.jar`，然後使用 `java -jar application.jar` 以執行之。欲設定在環境中伺服器執行個體上執行的程序，請於您的原始碼套件納入選用的 [Procfile](java-se-procfile.md)。若您的原始碼套件根目錄具有多個 JAR 檔案，或者您希望自訂 Java 命令來設定 JVM 選項，則必須使用 `Procfile`。

建議務必在原始碼套件和應用程式中，一併提供 `Procfile`。如此一來，就能精確掌控 Elastic Beanstalk 會針對應用程式執行哪些程序，以及這些程序會收到哪些引數。

欲在部署時編譯 Java 類別並於環境中 EC2 執行個體上執行其他建置命令，請將 [Buildfile](java-se-buildfile.md) 納入您的應用程式原始碼套件。`Buildfile` 可讓您依原狀部署原始碼，並可建置在伺服器上，而非於本機編譯 JAR。Java SE 平台包括常見的建置工具，可讓您在伺服器上進行建置作業。

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

## 設定您的 Java SE 環境
<a name="java-se-options"></a>

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

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

**在 Elastic Beanstalk 主控台中設定您的 Java SE 環境**

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

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

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

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

### 日誌選項
<a name="java-se-options-logs"></a>

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

### 靜態檔案
<a name="java-se-options-staticfiles"></a>

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

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

### 環境屬性
<a name="java-se-options-properties"></a>

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

在 Elastic Beanstalk 內所執行的 Java SE 環境中，可使用 `System.getenv()` 來存取環境變數。例如，您可使用下列程式碼，來將名為 `API_ENDPOINT` 的屬性讀取到變數：

```
String endpoint = System.getenv("API_ENDPOINT");
```

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

## Java SE 組態命名空間
<a name="java-se-namespaces"></a>

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

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

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

## Amazon Linux AMI (Amazon Linux 2 之前) Java SE 平台
<a name="java-se.alami"></a>

如果您的 Elastic Beanstalk Java SE 環境使用 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 SE 組態命名空間 — Amazon Linux AMI (AL1)
<a name="java-se.alami.namespaces"></a>

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

除了[所有平台皆支援的命名空間](command-options-general.md)，Java SE 平台亦支援一個平台特定的組態命名空間。`aws:elasticbeanstalk:container:java:staticfiles` 命名空間可讓您定義選項，將您 Web 應用程式的路徑對應至應用程式原始碼套件中內含靜態內容的資料夾。

例如，此選項 [option\$1settings](ebextensions-optionsettings.md) 程式碼片段會定義靜態檔案命名空間內的兩個選項。第一個會將路徑 `/public` 對應至名為 `public` 的資料夾，第二個則將路徑 `/images` 對應至名為 `img` 的資料夾：

```
option_settings:
  aws:elasticbeanstalk:container:java:staticfiles:
    /html: statichtml
    /images: staticimages
```

您使用此命名空間對應的資料夾，必須為原始碼套件根目錄內的實際資料夾。您無法將路徑對應至 JAR 檔案中的資料夾。

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

# 透過 Buildfile 在伺服器上建置 JAR
<a name="java-se-buildfile"></a>

您可於原始碼套件內的 `Buildfile` 檔案呼叫建置命令，藉此在您環境的 EC2 執行個體上，建置應用程式的類別檔案和 JAR。

`Buildfile` 中的命令僅能執行一次，且完成後必須終止，而 [Procfile](java-se-procfile.md) 的命令應於應用程式的使用壽命內持續執行，且被終止後會重新啟動。若要執行應用程式內的 JAR，請使用 `Procfile`。

如需 放置和語法的詳細資訊`Buildfile`，請參閱 [Buildfile 和 Procfile](platforms-linux-extend.build-proc.md)。

下列 `Buildfile` 範例執行 Apache Maven，藉此從原始碼建置 Web 應用程式。如需使用此功能的範例應用程式的詳細資訊，請參閱 [Java Web 應用程式範例](java-getstarted.md#java-getstarted-samples)。

**Example Buildfile**  

```
build: mvn assembly:assembly -DdescriptorId=jar-with-dependencies
```

Java SE 平台包含下列建置工具，您可從建置指令碼進行呼叫：
+ `javac` – Java 編譯器
+ `ant` – Apache Ant
+ `mvn` – Apache Maven
+ `gradle` – Gradle

# 使用 Procfile 設定應用程式程序
<a name="java-se-procfile"></a>

若您應用程式原始碼套件的根目錄內含多個 JAR 檔案，請務必納入 `Procfile` 檔案，以指示 Elastic Beanstalk 應執行的 JAR。您亦可為單一 JAR 應用程式納入 `Procfile` 檔案，藉此設定執行您應用程式的 Java 虛擬機器 (JVM)。

建議務必在原始碼套件和應用程式中，一併提供 `Procfile`。如此一來，就能精確掌控 Elastic Beanstalk 會針對應用程式執行哪些程序，以及這些程序會收到哪些引數。

如需撰寫和使用 的詳細資訊，`Procfile`請參閱 [Buildfile 和 Procfile](platforms-linux-extend.build-proc.md)。

**Example Procfile**  

```
web: java -Xms256m -jar server.jar 
cache: java -jar mycache.jar
web_foo: java -jar other.jar
```

執行應用程式中主要 JAR 的命令必須稱為 `web`，且必須為 `Procfile` 中列出的第一條命令。nginx 伺服器會將所有接收自您環境負載平衡器的 HTTP 請求，轉送至此應用程式。

Elastic Beanstalk 假設 Procfile 的所有項目應隨時執行，並自動重新啟動 Procfile 中定義的所有已終止的應用程式。欲執行將終止且不重新啟動的命令，請使用 [`Buildfile`](java-se-buildfile.md)。

## 在 Amazon Linux AMI (Amazon Linux 2 之前) 上使用 Procfile
<a name="java-se-procfile.alami"></a>

如果您的 Elastic Beanstalk Java SE 環境使用 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="java-se-procfile.alami.ports"></a>

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

如果您使用 `Procfile` 來執行多個應用程式，Amazon Linux AMI 平台版本上的 Elastic Beanstalk 預期每個額外的應用程式都須接聽編號比前一個多 100 的連接埠。Elastic Beanstalk 將每個應用程式內部可存取的 PORT 變數，設定為其預期應用程式執行所用的連接埠。您可呼叫 `System.getenv("PORT")`，藉此於應用程式程式碼內存取此變數。

在上述 `Procfile` 範例中，`web` 應用程式會接聽連接埠 5000，`cache` 會接聽連接埠 5100，而 `web_foo` 會接聽連接埠 5200。`web` 會讀取 `PORT` 變數，藉此設定其接聽的連接埠，並於該連接埠編號加 100 以判定 `cache` 接聽的連接埠，從而向其傳送請求。

# 設定代理伺服器
<a name="java-se-nginx"></a>

Elastic Beanstalk 使用 [nginx](https://www.nginx.com/) 做為反向代理伺服器，在連接埠 80 上將您的應用程式映射到 Elastic Load Balancing 負載平衡器。Elastic Beanstalk 提供了預設的 nginx 組態，您可以加以擴展，或使用自己的組態將其完全覆寫。

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

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

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

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

如果您的 Elastic Beanstalk Java SE 環境使用 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="java-se-nginx.alami.extending"></a>

若要擴展 Elastic Beanstalk 的預設 nginx 組態，請將 `.conf` 組態檔案加進您應用程式原始碼套件中名為 `.ebextensions/nginx/conf.d/` 的資料夾。Elastic Beanstalk nginx 組態會自動在此資料夾中加入 `.conf` 檔案。

```
~/workspace/my-app/
|-- .ebextensions
|   `-- nginx
|       `-- conf.d
|           `-- myconf.conf
`-- web.jar
```

若要完全覆寫 Elastic Beanstalk 預設 nginx 組態，請在 `.ebextensions/nginx/nginx.conf` 的原始碼套件中加入組態：

```
~/workspace/my-app/
|-- .ebextensions
|   `-- nginx
|       `-- nginx.conf
`-- web.jar
```

如果您覆寫了 Elastic Beanstalk nginx 組態，請在 `nginx.conf` 中加入下列行，以納入適用於 [Elastic Beanstalk 中的增強型運作狀態報告和監控](health-enhanced.md)、自動應用程式映射和靜態檔案的 Elastic Beanstalk 組態。

```
 include conf.d/elasticbeanstalk/*.conf;
```

以下來自 [Scorekeep 範例應用程式](https://github.com/aws-samples/eb-java-scorekeep/)的範例組態會覆寫 Elastic Beanstalk 的預設組態，以提供 `public` 的 `/var/app/current` 子目錄的靜態 Web 應用程式，其中 Java SE 平台複製應用程式原始程式碼。`/api` 位置轉發流量以在 `/api/` 下路由傳送到連接埠 5000 上的 Spring 應用程式接聽。根路徑的 Web 應用程式提供其他所有流量。

**Example**  

```
user                    nginx;
error_log               /var/log/nginx/error.log warn;
pid                     /var/run/nginx.pid;
worker_processes        auto;
worker_rlimit_nofile    33282;

events {
    worker_connections  1024;
}

http {
  include       /etc/nginx/mime.types;
  default_type  application/octet-stream;

  log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                    '$status $body_bytes_sent "$http_referer" '
                    '"$http_user_agent" "$http_x_forwarded_for"';

  include       conf.d/*.conf;

  map $http_upgrade $connection_upgrade {
      default     "upgrade";
  }

  server {
      listen        80 default_server;
      root /var/app/current/public;

      location / {
      }git pull
      

      location /api {
          proxy_pass          http://127.0.0.1:5000;
          proxy_http_version  1.1;

          proxy_set_header    Connection          $connection_upgrade;
          proxy_set_header    Upgrade             $http_upgrade;
          proxy_set_header    Host                $host;
          proxy_set_header    X-Real-IP           $remote_addr;
          proxy_set_header    X-Forwarded-For     $proxy_add_x_forwarded_for;
      }

      access_log    /var/log/nginx/access.log main;

      client_header_timeout 60;
      client_body_timeout   60;
      keepalive_timeout     60;
      gzip                  off;
      gzip_comp_level       4;

      # Include the Elastic Beanstalk generated locations
      include conf.d/elasticbeanstalk/01_static.conf;
      include conf.d/elasticbeanstalk/healthd.conf;
  }
}
```

# 將 Amazon RDS 資料庫執行個體新增至 Java Elastic Beanstalk 環境
<a name="java-rds"></a>

本主題提供了使用 Elastic Beanstalk 主控台建立 Amazon RDS 的說明。您可以使用 Amazon Relational Database Service (Amazon RDS) 資料庫執行個體存放由應用程式收集與修改的資料。資料庫可連接到您的環境並由 Elastic Beanstalk 管理，或者在外部建立與管理。

若您首次使用 Amazon RDS，請透過 Elastic Beanstalk 主控台將資料庫執行個體新增至測試環境，並確認您的應用程式是否可與其連接。

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

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 環境](using-features.managing.db.md)。如需有關設定外部資料庫搭配 Elastic Beanstalk 使用的說明，請參閱[搭配 Amazon RDS 使用 Elastic Beanstalk](AWSHowTo.RDS.md)。

欲連接至資料庫，請於您的應用程式新增合適的驅動程式 JAR 檔案、下載您程式碼的驅動程式類別，並使用 Elastic Beanstalk 提供的環境屬性建立連線物件。

**Topics**
+ [

## 下載 JDBC 驅動程式
](#java-rds-drivers)
+ [

## 連線至資料庫 (Java SE 平台)
](#java-rds-javase)
+ [

## 連線至資料庫 (Tomcat 平台)
](#java-rds-tomcat)
+ [

## 資料庫連線故障診斷
](#create_deploy_Java.rds.troubleshooting)

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

您將需要所選資料庫引擎的 JDBC 驅動程式 JAR 檔案。將 JAR 檔案儲存至您的原始碼，並在編譯會建立資料庫連結的類別時，將其納入 classpath。

您可於下列位置找到資料庫引擎最新的驅動程式：
+ **MySQL** – [MySQL 連接器/J](https://dev.mysql.com/downloads/connector/j/)
+ **Oracle SE-1** – [Oracle JDBC 驅動程式](http://www.oracle.com/technetwork/database/features/jdbc/index-091264.html)
+ **Postgres** – [PostgreSQL JDBC 驅動程式](https://jdbc.postgresql.org/)
+ **SQL Server** – [Microsoft JDBC 驅動程式](https://msdn.microsoft.com/en-us/sqlserver/aa937724.aspx)

欲使用 JDBC 驅動程式，請呼叫 `Class.forName()` 來載入，之後再於程式碼中透過 `DriverManager.getConnection()` 建立連結。

JDBC 使用的連線字串格式如下：

```
jdbc:driver://hostname:port/dbName?user=userName&password=password
```

您可從 Elastic Beanstalk 提供您應用程式的環境變數，擷取主機名稱、連接埠、資料庫名稱、使用者名稱和密碼。驅動程式名稱為您的資料庫類型和驅動程式版本專屬。下列為範例驅動程式名稱：
+ `mysql`適用於 MySQL 的 
+ `postgresql` (適用於 PostgreSQL)
+ `oracle:thin` (適用於 Oracle Thin)
+ `oracle:oci` (適用於 Oracle OCI)
+ `oracle:oci8` (適用於 Oracle OCI 8)
+ `oracle:kprb` (適用於 Oracle KPRB)
+ `sqlserver` (適用於 SQL Server)

## 連線至資料庫 (Java SE 平台)
<a name="java-rds-javase"></a>

在 Java SE 環境中，請使用 `System.getenv()` 從環境讀取連線變數。下列範例程式碼為會建立 PostgreSQL 資料庫連線的類別。

```
private static Connection getRemoteConnection() {
    if (System.getenv("RDS_HOSTNAME") != null) {
      try {
      Class.forName("org.postgresql.Driver");
      String dbName = System.getenv("RDS_DB_NAME");
      String userName = System.getenv("RDS_USERNAME");
      String password = System.getenv("RDS_PASSWORD");
      String hostname = System.getenv("RDS_HOSTNAME");
      String port = System.getenv("RDS_PORT");
      String jdbcUrl = "jdbc:postgresql://" + hostname + ":" + port + "/" + dbName + "?user=" + userName + "&password=" + password;
      logger.trace("Getting remote connection with connection string from environment variables.");
      Connection con = DriverManager.getConnection(jdbcUrl);
      logger.info("Remote connection successful.");
      return con;
    }
    catch (ClassNotFoundException e) { logger.warn(e.toString());}
    catch (SQLException e) { logger.warn(e.toString());}
    }
    return null;
  }
```

## 連線至資料庫 (Tomcat 平台)
<a name="java-rds-tomcat"></a>

在 Tomcat 環境中，環境屬性可做為透過 `System.getProperty()` 存取的系統屬性。

下列範例程式碼為會建立 PostgreSQL 資料庫連線的類別。

```
private static Connection getRemoteConnection() {
    if (System.getProperty("RDS_HOSTNAME") != null) {
      try {
      Class.forName("org.postgresql.Driver");
      String dbName = System.getProperty("RDS_DB_NAME");
      String userName = System.getProperty("RDS_USERNAME");
      String password = System.getProperty("RDS_PASSWORD");
      String hostname = System.getProperty("RDS_HOSTNAME");
      String port = System.getProperty("RDS_PORT");
      String jdbcUrl = "jdbc:postgresql://" + hostname + ":" + port + "/" + dbName + "?user=" + userName + "&password=" + password;
      logger.trace("Getting remote connection with connection string from environment variables.");
      Connection con = DriverManager.getConnection(jdbcUrl);
      logger.info("Remote connection successful.");
      return con;
    }
    catch (ClassNotFoundException e) { logger.warn(e.toString());}
    catch (SQLException e) { logger.warn(e.toString());}
    }
    return null;
  }
```

若您建立連線或執行 SQL 陳述式出現問題，請嘗試將下列程式碼放入 JSP 檔案。此程式碼會連線至資料庫執行個體、建立資料表並寫入其中。

```
<%@ page import="java.sql.*" %>
<%
  // Read RDS connection information from the environment
  String dbName = System.getProperty("RDS_DB_NAME");
  String userName = System.getProperty("RDS_USERNAME");
  String password = System.getProperty("RDS_PASSWORD");
  String hostname = System.getProperty("RDS_HOSTNAME");
  String port = System.getProperty("RDS_PORT");
  String jdbcUrl = "jdbc:mysql://" + hostname + ":" +
    port + "/" + dbName + "?user=" + userName + "&password=" + password;
  
  // Load the JDBC driver
  try {
    System.out.println("Loading driver...");
    Class.forName("com.mysql.jdbc.Driver");
    System.out.println("Driver loaded!");
  } catch (ClassNotFoundException e) {
    throw new RuntimeException("Cannot find the driver in the classpath!", e);
  }

  Connection conn = null;
  Statement setupStatement = null;
  Statement readStatement = null;
  ResultSet resultSet = null;
  String results = "";
  int numresults = 0;
  String statement = null;

  try {
    // Create connection to RDS DB instance
    conn = DriverManager.getConnection(jdbcUrl);
    
    // Create a table and write two rows
    setupStatement = conn.createStatement();
    String createTable = "CREATE TABLE Beanstalk (Resource char(50));";
    String insertRow1 = "INSERT INTO Beanstalk (Resource) VALUES ('EC2 Instance');";
    String insertRow2 = "INSERT INTO Beanstalk (Resource) VALUES ('RDS Instance');";
    
    setupStatement.addBatch(createTable);
    setupStatement.addBatch(insertRow1);
    setupStatement.addBatch(insertRow2);
    setupStatement.executeBatch();
    setupStatement.close();
    
  } catch (SQLException ex) {
    // Handle any errors
    System.out.println("SQLException: " + ex.getMessage());
    System.out.println("SQLState: " + ex.getSQLState());
    System.out.println("VendorError: " + ex.getErrorCode());
  } finally {
    System.out.println("Closing the connection.");
    if (conn != null) try { conn.close(); } catch (SQLException ignore) {}
  }

  try {
    conn = DriverManager.getConnection(jdbcUrl);
    
    readStatement = conn.createStatement();
    resultSet = readStatement.executeQuery("SELECT Resource FROM Beanstalk;");

    resultSet.first();
    results = resultSet.getString("Resource");
    resultSet.next();
    results += ", " + resultSet.getString("Resource");
    
    resultSet.close();
    readStatement.close();
    conn.close();

  } catch (SQLException ex) {
    // Handle any errors
    System.out.println("SQLException: " + ex.getMessage());
    System.out.println("SQLState: " + ex.getSQLState());
    System.out.println("VendorError: " + ex.getErrorCode());
  } finally {
       System.out.println("Closing the connection.");
      if (conn != null) try { conn.close(); } catch (SQLException ignore) {}
  }
%>
```

欲顯示結果，請將下列程式碼放入 JSP 檔案 HTML 部分的本文中。

```
<p>Established connection to RDS. Read first two rows: <%= results %></p>
```

## 資料庫連線故障診斷
<a name="create_deploy_Java.rds.troubleshooting"></a>

**試用 Amazon Q Developer CLI 進行 AI 輔助故障診斷**  
 Amazon Q Developer CLI 可協助您快速疑難排解環境問題。Q CLI 透過檢查環境狀態、檢閱事件、分析日誌和詢問釐清問題來提供解決方案。如需詳細資訊和詳細的逐步解說，請參閱 AWS 部落格中的[使用 Amazon Q Developer CLI 疑難排解 Elastic Beanstalk 環境](https://aws.amazon.com/blogs/devops/troubleshooting-elastic-beanstalk-environments-with-amazon-q-developer-cli/)。

若您從應用程式建立資料庫連線出現問題，請檢視 Web 容器日誌和資料庫。

### 檢視日誌
<a name="create_deploy_Java.rds.troubleshooting.logs"></a>

您可於 Eclipse 內檢視 Elastic Beanstalk 環境的所有日誌。如果您沒有開啟 AWS Explorer 檢視，請選擇工具列中橘色 AWS 圖示旁的箭頭，然後選擇**顯示 AWS Explorer 檢視**。展開 **AWS Elastic Beanstalk** 以及您的環境名稱，然後開啟伺服器的內容選單 (按一下滑鼠右鍵)。選擇 **Open in WTP Server Editor (於 WTP 伺服器編輯器開啟)**。

 選擇 **Server (伺服器)** 檢視的 **Log (日誌)** 索引標籤，以查看您環境的彙整日誌。欲開啟最新的日誌，選擇頁面右上角的 **Refresh (重新整理)** 按鈕。

 向下捲動在 `/var/log/tomcat7/catalina.out` 中找到 Tomcat 日誌。若您在之前的數個範例已載入網頁，可能會看到下列內容。

```
-------------------------------------
/var/log/tomcat7/catalina.out
-------------------------------------
INFO: Server startup in 9285 ms
Loading driver...
Driver loaded!
SQLException: Table 'Beanstalk' already exists
SQLState: 42S01
VendorError: 1050
Closing the connection.
Closing the connection.
```

Web 應用程式傳送至標準輸出的所有資訊會顯示於 Web 容器日誌。在上述範例中，應用程式在每次載入頁面時都嘗試建立資料表。這導致第一次載入頁面後，每次載入頁面都會發現 SQL 例外狀況。

以範例而言，上述為可接受情況。但實際在應用程式中，請於結構描述物件中保存資料庫定義，在模型類別中執行交易，並與控制器 Servlet 協調請求。

### 連接到 RDS 資料庫執行個體
<a name="create_deploy_Java.rds.troubleshooting.connecting"></a>

 您可使用 MySQL 用戶端應用程式，直接連接至 Elastic Beanstalk 環境中的 RDS 資料庫執行個體。

 首先，請開放對 RDS 資料庫執行個體的安全群組，以允許來自您電腦的流量。

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

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

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

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

1. 在 **Endpoint (端點)** 旁，選擇 Amazon RDS 主控台連結。

1. 在 **RDS Dashboard (RDS 儀表板)** 執行個體詳細資訊頁面中的 **Security and Network (安全與網路)** 下，選擇 **Security Groups (安全群組)** 旁開頭為 *rds-* 的安全群組。
**注意**  
資料庫可能有多個項目均標示為 **Security Groups (安全群組)**。僅在您較舊的帳戶沒有預設 [Amazon Virtual Private Cloud](https://docs.aws.amazon.com/vpc/latest/userguide/) (Amazon VPC) 的情況下，才使用第一個項目 (開頭為 *awseb*)。

1. 在 **Security group details (安全群組詳細資訊)** 中，選擇 **Inbound (傳入)** 索引標籤，然後選擇 **Edit (編輯)**。

1. 新增 MySQL (連接埠 3306) 的規則，以允許來自您以 CIDR 格式指定的 IP 地址的流量。

1. 選擇 **Save** (儲存)。變更會立即生效。

 返回您環境的 Elastic Beanstalk 組態詳細資訊，並記下端點。您將使用該網域名稱連接至 RDS 資料庫執行個體。

 安裝 MySQL 用戶端並於連接埠 3306 啟動資料庫的連線。在 Windows 上，請自 MySQL 首頁安裝 MySQL Workbench，並依提示操作。

 在 Linux 上，請使用適用您的分發的套件管理工具，來安裝 MySQL 用戶端。下列範例運作於 Ubuntu 和其他 Debian 的衍生產品。

```
// Install MySQL client
$ sudo apt-get install mysql-client-5.5
...
// Connect to database
$ mysql -h aas839jo2vwhwb.cnubrrfwfka8.us-west-2.rds.amazonaws.com -u username -ppassword ebdb
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 117
Server version: 5.5.40-log Source distribution
...
```

連線之後，您可執行 SQL 命令來查看資料庫的狀態，了解資料表和列是否已建立和其他資訊。

```
mysql> SELECT Resource from Beanstalk;
+--------------+
| Resource     |
+--------------+
| EC2 Instance |
| RDS Instance |
+--------------+
2 rows in set (0.01 sec)
```

# Java 工具和資源
<a name="create_deploy_Java.resources"></a>

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


****  

|  資源  |  Description  | 
| --- | --- | 
|  [AWS Java 開發論壇](https://forums.aws.amazon.com/forum.jspa?forumID=70)  | 提出您的問題，並取得意見回饋。 | 
|  [Java 開發人員中心](https://aws.amazon.com/java/)  | 可取得範本程式碼、文件、工具和其他資源等一應俱全的場所。 | 