本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 在实例上配置 HTTPS 终止
<a name="https-singleinstance"></a>

您可使用[配置文件](ebextensions.md)配置将流量传递至应用程序的代理服务器，使其终止 HTTPS 连接。如果您希望在单一实例环境中使用 HTTPS，或如果您配置负载均衡器为传递流量而无需解密，这种方式将会十分有用。

要启用 HTTPS，您必须允许端口 443 上的传入流量流向运行 Elastic Beanstalk 应用程序的 EC2 实例。为此，您可以使用配置文件中的`Resources`密钥将端口 443 的规则添加到 AWSEBSecurity组安全组的入口规则中。

以下代码段将传入规则添加到 `AWSEBSecurityGroup` 安全组，该安全组为单一实例环境的所有流量打开端口 443。

**`.ebextensions/https-instance-securitygroup.config`**

```
Resources:
  sslSecurityGroupIngress: 
    Type: AWS::EC2::SecurityGroupIngress
    Properties:
      GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
      IpProtocol: tcp
      ToPort: 443
      FromPort: 443
      CidrIp: 0.0.0.0/0
```

在默认 [Amazon Virtual Private Cloud](https://docs.aws.amazon.com/vpc/latest/userguide/) (Amazon VPC) 的负载均衡环境中，您可以将此策略修改为仅接受来自负载均衡器的流量。有关示例，请参阅 [在负载均衡的 Elastic Beanstalk 环境中配置 end-to-end加密](configuring-https-endtoend.md)。

**Topics**
+ [在运行 Docker 的 EC2 实例上终止 HTTPS](https-singleinstance-docker.md)
+ [在运行 Go 的 EC2 实例上终止 HTTPS](https-singleinstance-go.md)
+ [终止运行 Java SE 的 EC2 实例上的 HTTPS](https-singleinstance-java.md)
+ [在运行 Node.js 的 EC2 实例上终止 HTTPS](https-singleinstance-nodejs.md)
+ [在运行 PHP 的 EC2 实例上终止 HTTPS](https-singleinstance-php.md)
+ [在运行 Python 的 EC2 实例上终止 HTTPS](https-singleinstance-python.md)
+ [在运行 Ruby 的 EC2 实例上终止 HTTPS](https-singleinstance-ruby.md)
+ [在运行 Tomcat 的 EC2 实例上终止 HTTPS](https-singleinstance-tomcat.md)
+ [在运行 .NET Core on Linux 的 Amazon EC2 实例上终止 HTTPS](https-singleinstance-dotnet-linux.md)
+ [在运行.NET 的亚马逊 EC2 实例上终止 HTTPS](SSLNET.SingleInstance.md)

# 在运行 Docker 的 EC2 实例上终止 HTTPS
<a name="https-singleinstance-docker"></a>

对于 Docker 容器，您使用[配置文件](ebextensions.md)启用 HTTPS。

将以下代码段添加到您的配置文件中，按照提示替换证书和私有密钥资料，并将该文件保存在源包的 `.ebextensions` 目录中。该配置文件执行以下任务：
+ `files` 密钥在实例上创建以下文件：  
`/etc/nginx/conf.d/https.conf`  
配置 nginx 服务器。nginx 服务启动时加载此文件。  
`/etc/pki/tls/certs/server.crt`  
在实例上创建证书文件。*certificate file contents*替换为证书的内容。  
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
如果您有中间证书，请将其放入 `server.crt` 中您的站点证书的后面：  

  ```
        -----BEGIN CERTIFICATE-----
    certificate file contents
    -----END CERTIFICATE-----
    -----BEGIN CERTIFICATE-----
    first intermediate certificate
    -----END CERTIFICATE-----
    -----BEGIN CERTIFICATE-----
    second intermediate certificate
    -----END CERTIFICATE-----
  ```  
`/etc/pki/tls/certs/server.key`  
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。

**Example .ebextensions/https-instance.config**  

```
files:
  /etc/nginx/conf.d/https.conf:
    mode: "000644"
    owner: root
    group: root
    content: |
      # HTTPS Server
      
      server {
        listen 443;
        server_name localhost;
        
        ssl on;
        ssl_certificate /etc/pki/tls/certs/server.crt;
        ssl_certificate_key /etc/pki/tls/certs/server.key;
        
        ssl_session_timeout 5m;
        
        ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
        ssl_prefer_server_ciphers on;
        
        location / {
          proxy_pass http://docker;
          proxy_http_version 1.1;
          
          proxy_set_header Connection "";
          proxy_set_header Host $host;
          proxy_set_header X-Real-IP $remote_addr;
          proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
          proxy_set_header X-Forwarded-Proto https;
        }
      }
      
  /etc/pki/tls/certs/server.crt:
    mode: "000400"
    owner: root
    group: root
    content: |
      -----BEGIN CERTIFICATE-----
      certificate file contents
      -----END CERTIFICATE-----
      
  /etc/pki/tls/certs/server.key:
    mode: "000400"
    owner: root
    group: root
    content: |
      -----BEGIN RSA PRIVATE KEY-----
      private key contents # See note below.
      -----END RSA PRIVATE KEY-----
```

**注意**  
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。

在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。

**Example .ebextensions/ .config https-instance-single**  

```
Resources:
  sslSecurityGroupIngress: 
    Type: AWS::EC2::SecurityGroupIngress
    Properties:
      GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
      IpProtocol: tcp
      ToPort: 443
      FromPort: 443
      CidrIp: 0.0.0.0/0
```

对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end

# 在运行 Go 的 EC2 实例上终止 HTTPS
<a name="https-singleinstance-go"></a>

对于 Go 容器类型，您可以使用[配置文件](ebextensions.md)和 nginx 配置文件（用于将 nginx 服务器配置为使用 HTTPS）来启用 HTTPS。

将以下代码段添加到您的配置文件中，按照提示替换证书和私有密钥占位符，并将该文件保存在源包的 `.ebextensions` 目录中。该配置文件执行以下任务：
+ `Resources` 密钥在您的环境实例使用的安全组上启用端口 443。
+ `files` 密钥在实例上创建以下文件：  
`/etc/pki/tls/certs/server.crt`  
在实例上创建证书文件。*certificate file contents*替换为证书的内容。  
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
如果您有中间证书，请将其放入 `server.crt` 中您的站点证书的后面：  

  ```
        -----BEGIN CERTIFICATE-----
    certificate file contents
    -----END CERTIFICATE-----
    -----BEGIN CERTIFICATE-----
    first intermediate certificate
    -----END CERTIFICATE-----
    -----BEGIN CERTIFICATE-----
    second intermediate certificate
    -----END CERTIFICATE-----
  ```  
`/etc/pki/tls/certs/server.key`  
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。

**Example .ebextensions/https-instance.config**  

```
files:
  /etc/pki/tls/certs/server.crt:
    content: |
      -----BEGIN CERTIFICATE-----
      certificate file contents
      -----END CERTIFICATE-----
      
  /etc/pki/tls/certs/server.key:
    content: |      
      -----BEGIN RSA PRIVATE KEY-----
      private key contents # See note below.
      -----END RSA PRIVATE KEY-----
```

**注意**  
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。

将以下内容放置在源包的 `.conf` 目录内扩展名为 `.ebextensions/nginx/conf.d/` 的文件中 (例如 `.ebextensions/nginx/conf.d/https.conf`)。*app\$1port*替换为应用程序监听的端口号。此示例配置 nginx 服务器使用 SSL 侦听端口 443。有关 Go 平台上的这些配置文件的更多信息，请参阅 [配置代理服务器](go-nginx.md)。

**Example 。 ebextensions/nginx/conf.d/https.conf**  

```
# HTTPS server

server {
    listen       443;
    server_name  localhost;
    
    ssl                  on;
    ssl_certificate      /etc/pki/tls/certs/server.crt;
    ssl_certificate_key  /etc/pki/tls/certs/server.key;
    
    ssl_session_timeout  5m;
    
    ssl_protocols  TLSv1 TLSv1.1 TLSv1.2;
    ssl_prefer_server_ciphers   on;
    
    location / {
        proxy_pass  http://localhost:app_port;
        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;
        proxy_set_header        X-Forwarded-Proto https;
    }
}
```

在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。

**Example .ebextensions/ .config https-instance-single**  

```
Resources:
  sslSecurityGroupIngress: 
    Type: AWS::EC2::SecurityGroupIngress
    Properties:
      GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
      IpProtocol: tcp
      ToPort: 443
      FromPort: 443
      CidrIp: 0.0.0.0/0
```

对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end

# 终止运行 Java SE 的 EC2 实例上的 HTTPS
<a name="https-singleinstance-java"></a>

对于 Java SE 容器类型，您可使用 .ebextensions [配置文件](ebextensions.md)和 nginx 配置文件（用于将 nginx 服务器配置为使用 HTTPS）来启用 HTTPS。

所有 AL2023/AL2 平台都支持统一的代理配置功能。有关在运行 AL2023 /的平台版本上配置代理服务器的更多信息AL2，请参阅[反向代理配置](platforms-linux-extend.proxy.md)。

将以下代码段添加到您的配置文件中，按照提示替换证书和私有密钥占位符，并将该文件保存在 `.ebextensions` 目录中。该配置文件执行以下任务：
+ `files` 密钥在实例上创建以下文件：  
`/etc/pki/tls/certs/server.crt`  
在实例上创建证书文件。*certificate file contents*替换为证书的内容。  
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
如果您有中间证书，请将其放入 `server.crt` 中您的站点证书的后面：  

  ```
        -----BEGIN CERTIFICATE-----
    certificate file contents
    -----END CERTIFICATE-----
    -----BEGIN CERTIFICATE-----
    first intermediate certificate
    -----END CERTIFICATE-----
    -----BEGIN CERTIFICATE-----
    second intermediate certificate
    -----END CERTIFICATE-----
  ```  
`/etc/pki/tls/certs/server.key`  
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。

**Example .ebextensions/https-instance.config**  

```
files:
  /etc/pki/tls/certs/server.crt:
    content: |
      -----BEGIN CERTIFICATE-----
      certificate file contents
      -----END CERTIFICATE-----
      
  /etc/pki/tls/certs/server.key:
    content: |
      -----BEGIN RSA PRIVATE KEY-----
      private key contents # See note below.
      -----END RSA PRIVATE KEY-----
```

**注意**  
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。

将以下内容放置在源包的 `.conf` 目录内扩展名为 `.ebextensions/nginx/conf.d/` 的文件中 (例如 `.ebextensions/nginx/conf.d/https.conf`)。*app\$1port*替换为应用程序监听的端口号。此示例配置 nginx 服务器使用 SSL 侦听端口 443。有关 Java SE 平台上的这些配置文件的更多信息，请参阅 [配置代理服务器](java-se-nginx.md)。

**Example 。 ebextensions/nginx/conf.d/https.conf**  

```
# HTTPS server

server {
    listen       443;
    server_name  localhost;
    
    ssl                  on;
    ssl_certificate      /etc/pki/tls/certs/server.crt;
    ssl_certificate_key  /etc/pki/tls/certs/server.key;
    
    ssl_session_timeout  5m;
    
    ssl_protocols  TLSv1 TLSv1.1 TLSv1.2;
    ssl_prefer_server_ciphers   on;
    
    location / {
        proxy_pass  http://localhost:app_port;
        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;
        proxy_set_header        X-Forwarded-Proto https;
    }
}
```

在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。

**Example .ebextensions/ .config https-instance-single**  

```
Resources:
  sslSecurityGroupIngress: 
    Type: AWS::EC2::SecurityGroupIngress
    Properties:
      GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
      IpProtocol: tcp
      ToPort: 443
      FromPort: 443
      CidrIp: 0.0.0.0/0
```

对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end

# 在运行 Node.js 的 EC2 实例上终止 HTTPS
<a name="https-singleinstance-nodejs"></a>

以下示例配置文件[扩展了默认 nginx](nodejs-platform-proxy.md) 配置，使其监听端口 443 并 SSL/TLS 终止使用公有证书和私钥的连接。

如果已为[增强型运行状况报告](health-enhanced.md)配置环境，则需要配置 nginx 以生成访问日志。为此，通过删除前导 `# For enhanced health...` 字符，在显示为 `#` 的注释下方取消对行块的注释。

**Example .ebextensions/https-instance.config**  

```
files:
  /etc/nginx/conf.d/https.conf:
    mode: "000644"
    owner: root
    group: root
    content: |
      # HTTPS server

      server {
          listen       443;
          server_name  localhost;
          
          ssl                  on;
          ssl_certificate      /etc/pki/tls/certs/server.crt;
          ssl_certificate_key  /etc/pki/tls/certs/server.key;
          
          ssl_session_timeout  5m;
          
          ssl_protocols  TLSv1 TLSv1.1 TLSv1.2;
          ssl_prefer_server_ciphers   on;

          # For enhanced health reporting support, uncomment this block:

          #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;
              proxy_set_header        X-Forwarded-Proto https;
          }
      }
      
  /etc/pki/tls/certs/server.crt:
    mode: "000400"
    owner: root
    group: root
    content: |
      -----BEGIN CERTIFICATE-----
      certificate file contents
      -----END CERTIFICATE-----
      
  /etc/pki/tls/certs/server.key:
    mode: "000400"
    owner: root
    group: root
    content: |
      -----BEGIN RSA PRIVATE KEY-----
      private key contents # See note below.
      -----END RSA PRIVATE KEY-----
```

`files` 密钥在实例上创建以下文件：

`/etc/nginx/conf.d/https.conf`  
配置 nginx 服务器。nginx 服务启动时加载此文件。

`/etc/pki/tls/certs/server.crt`  
在实例上创建证书文件。*certificate file contents*替换为证书的内容。  
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
如果您有中间证书，请将其放入 `server.crt` 中您的站点证书的后面：  

```
      -----BEGIN CERTIFICATE-----
  certificate file contents
  -----END CERTIFICATE-----
  -----BEGIN CERTIFICATE-----
  first intermediate certificate
  -----END CERTIFICATE-----
  -----BEGIN CERTIFICATE-----
  second intermediate certificate
  -----END CERTIFICATE-----
```

`/etc/pki/tls/certs/server.key`  
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。

**注意**  
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。

在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。

**Example .ebextensions/ .config https-instance-single**  

```
Resources:
  sslSecurityGroupIngress: 
    Type: AWS::EC2::SecurityGroupIngress
    Properties:
      GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
      IpProtocol: tcp
      ToPort: 443
      FromPort: 443
      CidrIp: 0.0.0.0/0
```

对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end

# 在运行 PHP 的 EC2 实例上终止 HTTPS
<a name="https-singleinstance-php"></a>

对于 PHP 容器类型，您可使用[配置文件](ebextensions.md)来允许 Apache HTTP Server 使用 HTTPS。

将以下代码段添加到您的配置文件中，按照提示替换证书和私有密钥资料，并将该文件保存在源包的 `.ebextensions` 目录中。

该配置文件执行以下任务：
+ `packages` 密钥使用 yum 安装 `mod24_ssl`。
+ `files` 密钥在实例上创建以下文件：  
`/etc/httpd/conf.d/ssl.conf`  
配置 Apache 服务器。此文件在 Apache 服务启动时加载。  
`/etc/pki/tls/certs/server.crt`  
在实例上创建证书文件。*certificate file contents*替换为证书的内容。  
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
如果您有中间证书，请将其放入 `server.crt` 中您的站点证书的后面：  

  ```
        -----BEGIN CERTIFICATE-----
    certificate file contents
    -----END CERTIFICATE-----
    -----BEGIN CERTIFICATE-----
    first intermediate certificate
    -----END CERTIFICATE-----
    -----BEGIN CERTIFICATE-----
    second intermediate certificate
    -----END CERTIFICATE-----
  ```  
`/etc/pki/tls/certs/server.key`  
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。

**Example .ebextensions/https-instance.config**  

```
packages:
  yum:
    mod24_ssl : []

files:
  /etc/httpd/conf.d/ssl.conf:
    mode: "000644"
    owner: root
    group: root
    content: |
      LoadModule ssl_module modules/mod_ssl.so
      Listen 443
      <VirtualHost *:443>
        <Proxy *>
          Order deny,allow
          Allow from all
        </Proxy>

        SSLEngine             on
        SSLCertificateFile    "/etc/pki/tls/certs/server.crt"
        SSLCertificateKeyFile "/etc/pki/tls/certs/server.key"
        SSLCipherSuite        EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH
        SSLProtocol           All -SSLv2 -SSLv3
        SSLHonorCipherOrder   On
        SSLSessionTickets     Off
        
        Header always set Strict-Transport-Security "max-age=63072000; includeSubdomains; preload"
        Header always set X-Frame-Options DENY
        Header always set X-Content-Type-Options nosniff
        
        ProxyPass / http://localhost:80/ retry=0
        ProxyPassReverse / http://localhost:80/
        ProxyPreserveHost on
        RequestHeader set X-Forwarded-Proto "https" early
        
      </VirtualHost>
      
  /etc/pki/tls/certs/server.crt:
    mode: "000400"
    owner: root
    group: root
    content: |
      -----BEGIN CERTIFICATE-----
      certificate file contents
      -----END CERTIFICATE-----
      
  /etc/pki/tls/certs/server.key:
    mode: "000400"
    owner: root
    group: root
    content: |
      -----BEGIN RSA PRIVATE KEY-----
      private key contents # See note below.
      -----END RSA PRIVATE KEY-----
```

**注意**  
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。

在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。

**Example .ebextensions/ .config https-instance-single**  

```
Resources:
  sslSecurityGroupIngress: 
    Type: AWS::EC2::SecurityGroupIngress
    Properties:
      GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
      IpProtocol: tcp
      ToPort: 443
      FromPort: 443
      CidrIp: 0.0.0.0/0
```

对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end

# 在运行 Python 的 EC2 实例上终止 HTTPS
<a name="https-singleinstance-python"></a>

对于使用 Apache HTTP Server 和 Web Server Gateway Interface (WSGI) 的 Python 容器类型，您可使用[配置文件](ebextensions.md)来允许 Apache HTTP Server 使用 HTTPS。

将以下代码段添加到您的[配置文件](ebextensions.md)中，按照提示替换证书和私有密钥资料，并将该文件保存在源包的 `.ebextensions` 目录中。该配置文件执行以下任务：
+ `packages` 密钥使用 yum 安装 `mod_ssl`。
+ `files` 密钥在实例上创建以下文件：  
`/etc/httpd/conf.d/ssl.conf`  
配置 Apache 服务器。如果您的应用程序的名称不是 `application.py`，请将 `WSGIScriptAlias` 的值中突出显示的文本替换为您的应用程序的本地路径。例如，django 应用程序的路径可能是 `django/wsgi.py`。此位置应与您为环境设置的 `WSGIPath` 选项值相符。  
根据您的应用程序的要求，您可能还需要向 **python-path** 参数添加其他目录。  
`/etc/pki/tls/certs/server.crt`  
在实例上创建证书文件。*certificate file contents*替换为证书的内容。  
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
如果您有中间证书，请将其放入 `server.crt` 中您的站点证书的后面：  

  ```
        -----BEGIN CERTIFICATE-----
    certificate file contents
    -----END CERTIFICATE-----
    -----BEGIN CERTIFICATE-----
    first intermediate certificate
    -----END CERTIFICATE-----
    -----BEGIN CERTIFICATE-----
    second intermediate certificate
    -----END CERTIFICATE-----
  ```  
`/etc/pki/tls/certs/server.key`  
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。
+ `container_commands` 密钥在一切配置完成后停止 httpd 服务，以便该服务使用新的 `https.conf` 文件和证书。

**注意**  
该示例仅可用于使用 [Python](create-deploy-python-container.md) 平台的环境。

**Example .ebextensions/https-instance.config**  

```
packages:
  yum:
    mod_ssl: []
    
files:
  /etc/httpd/conf.d/ssl.conf:
    mode: "000644"
    owner: root
    group: root
    content: |
      LoadModule wsgi_module modules/mod_wsgi.so
      WSGIPythonHome /var/app/venv/staging-LQM1lest
      WSGISocketPrefix run/wsgi
      WSGIRestrictEmbedded On
      Listen 443
      <VirtualHost *:443>
        SSLEngine on
        SSLCertificateFile "/etc/pki/tls/certs/server.crt"
        SSLCertificateKeyFile "/etc/pki/tls/certs/server.key"
        
        Alias /static/ /var/app/current/static/
        <Directory /var/app/current/static>
        Order allow,deny
        Allow from all
        </Directory>
        
        WSGIScriptAlias / /var/app/current/application.py
        
        <Directory /var/app/current>
        Require all granted
        </Directory>
        
        WSGIDaemonProcess wsgi-ssl processes=1 threads=15 display-name=%{GROUP} \
          python-path=/var/app/current \
          python-home=/var/app/venv/staging-LQM1lest \
          home=/var/app/current \
          user=webapp \
          group=webapp
        WSGIProcessGroup wsgi-ssl
        
      </VirtualHost>
      
  /etc/pki/tls/certs/server.crt:
    mode: "000400"
    owner: root
    group: root
    content: |
      -----BEGIN CERTIFICATE-----
      certificate file contents
      -----END CERTIFICATE-----
       
  /etc/pki/tls/certs/server.key:
    mode: "000400"
    owner: root
    group: root
    content: |
      -----BEGIN RSA PRIVATE KEY-----
      private key contents # See note below.
      -----END RSA PRIVATE KEY-----
      
container_commands:
  01killhttpd:
    command: "killall httpd"
  02waitforhttpddeath:
    command: "sleep 3"
```

**注意**  
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。

**Amazon Linux 2023 环境注意事项**  
在 Amazon Linux 2023 上，必须单独安装 `mod_wsgi`，因为它在软件包存储库中不可用。有关安装说明，请参阅 PyPI 上的 [mod\$1wsgi](https://pypi.org/project/mod-wsgi/)。

在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。

**Example .ebextensions/ .config https-instance-single**  

```
Resources:
  sslSecurityGroupIngress: 
    Type: AWS::EC2::SecurityGroupIngress
    Properties:
      GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
      IpProtocol: tcp
      ToPort: 443
      FromPort: 443
      CidrIp: 0.0.0.0/0
```

对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end

# 在运行 Ruby 的 EC2 实例上终止 HTTPS
<a name="https-singleinstance-ruby"></a>

对于 Ruby 容器类型，启用 HTTPS 的方式取决于所用应用程序服务器的类型。

**Topics**
+ [为使用 Puma 的 Ruby 配置 HTTPS](#Puma)
+ [为使用 Passenger 的 Ruby 配置 HTTPS](#Passenger)

## 为使用 Puma 的 Ruby 配置 HTTPS
<a name="Puma"></a>

对于使用 Puma 作为应用程序服务器的 Ruby 容器类型，您可使用[配置文件](ebextensions.md)启用 HTTPS。

将以下代码段添加到您的配置文件中，按照提示替换证书和私有密钥资料，并将该文件保存在源包的 `.ebextensions` 目录中。该配置文件执行以下任务：
+ `files` 密钥在实例上创建以下文件：  
`/etc/nginx/conf.d/https.conf`  
配置 nginx 服务器。nginx 服务启动时加载此文件。  
`/etc/pki/tls/certs/server.crt`  
在实例上创建证书文件。*certificate file contents*替换为证书的内容。  
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
如果您有中间证书，请将其放入 `server.crt` 中您的站点证书的后面：  

  ```
        -----BEGIN CERTIFICATE-----
    certificate file contents
    -----END CERTIFICATE-----
    -----BEGIN CERTIFICATE-----
    first intermediate certificate
    -----END CERTIFICATE-----
    -----BEGIN CERTIFICATE-----
    second intermediate certificate
    -----END CERTIFICATE-----
  ```  
`/etc/pki/tls/certs/server.key`  
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。

**Example .ebextensions/https-instance.config**  

```
files:
  /etc/nginx/conf.d/https.conf:
    content: |
      # HTTPS server

      server {
          listen       443;
          server_name  localhost;
          
          ssl                  on;
          ssl_certificate      /etc/pki/tls/certs/server.crt;
          ssl_certificate_key  /etc/pki/tls/certs/server.key;
          
          ssl_session_timeout  5m;
          
          ssl_protocols  TLSv1 TLSv1.1 TLSv1.2;
          ssl_prefer_server_ciphers   on;
          
          location / {
              proxy_pass  http://my_app;
              proxy_set_header        Host            $host;
              proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
              proxy_set_header        X-Forwarded-Proto https;
          }

          location /assets {
            alias /var/app/current/public/assets;
            gzip_static on;
            gzip on;
            expires max;
            add_header Cache-Control public;
          }

          location /public {
            alias /var/app/current/public;
            gzip_static on;
            gzip on;
            expires max;
            add_header Cache-Control public;
          }
      }

  /etc/pki/tls/certs/server.crt:
    content: |
      -----BEGIN CERTIFICATE-----
      certificate file contents
      -----END CERTIFICATE-----
      
  /etc/pki/tls/certs/server.key:
    content: |      
      -----BEGIN RSA PRIVATE KEY-----
      private key contents # See note below.
      -----END RSA PRIVATE KEY-----
```

**注意**  
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。

在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。

**Example .ebextensions/ .config https-instance-single**  

```
Resources:
  sslSecurityGroupIngress: 
    Type: AWS::EC2::SecurityGroupIngress
    Properties:
      GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
      IpProtocol: tcp
      ToPort: 443
      FromPort: 443
      CidrIp: 0.0.0.0/0
```

对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end

## 为使用 Passenger 的 Ruby 配置 HTTPS
<a name="Passenger"></a>

对于使用 Passenger 作为应用程序服务器的 Ruby 容器类型，您可同时使用配置文件和 JSON 文件启用 HTTPS。

**为使用 Passenger 的 Ruby 配置 HTTPS**

1. 将以下代码段添加到您的配置文件中，按照提示替换证书和私有密钥资料，并将该文件保存在源包的 `.ebextensions` 目录中。该配置文件执行以下任务：
   + `files` 密钥在实例上创建以下文件：  
`/etc/pki/tls/certs/server.crt`  
在实例上创建证书文件。*certificate file contents*替换为证书的内容。  
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
如果您有中间证书，请将其放入 `server.crt` 中您的站点证书的后面：  

     ```
           -----BEGIN CERTIFICATE-----
       certificate file contents
       -----END CERTIFICATE-----
       -----BEGIN CERTIFICATE-----
       first intermediate certificate
       -----END CERTIFICATE-----
       -----BEGIN CERTIFICATE-----
       second intermediate certificate
       -----END CERTIFICATE-----
     ```  
`/etc/pki/tls/certs/server.key`  
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。  
**Example 用于为使用 Passenger 的 Ruby 配置 HTTPS 的 .Ebextensions 代码段**  

   ```
   files:
     /etc/pki/tls/certs/server.crt:
       content: |
         -----BEGIN CERTIFICATE-----
         certificate file contents
         -----END CERTIFICATE-----
         
     /etc/pki/tls/certs/server.key:
       content: |      
         -----BEGIN RSA PRIVATE KEY-----
         private key contents # See note below.
         -----END RSA PRIVATE KEY-----
   ```
**注意**  
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。

1. 创建一个文本文件并将以下 JSON 添加到该文件。将该文件保存在源包的名为 `passenger-standalone.json` 的根目录中。此 JSON 文件将 Passenger 配置为使用 HTTPS。
**重要**  
此 JSON 文件不得包含字节顺序标记 (BOM)。如果此文件包含字节顺序标记，则 Passenger JSON 库将不会正确读取此文件，并且 Passenger 服务将不会启动。  
**Example passenger-standalone.json**  

   ```
   {
     "ssl" : true,
     "ssl_port" : 443,
     "ssl_certificate" : "/etc/pki/tls/certs/server.crt",
     "ssl_certificate_key" : "/etc/pki/tls/certs/server.key"
   }
   ```

在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。

**Example .ebextensions/ .config https-instance-single**  

```
Resources:
  sslSecurityGroupIngress: 
    Type: AWS::EC2::SecurityGroupIngress
    Properties:
      GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
      IpProtocol: tcp
      ToPort: 443
      FromPort: 443
      CidrIp: 0.0.0.0/0
```

对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end

# 在运行 Tomcat 的 EC2 实例上终止 HTTPS
<a name="https-singleinstance-tomcat"></a>

对于 Tomcat 容器类型，您可使用[配置文件](ebextensions.md)来允许 HTTP Server 在充当 Tomcat 的反向代理时使用 HTTPS。

将以下代码段添加到您的配置文件中，按照提示替换证书和私有密钥资料，并将该文件保存在源包的 `.ebextensions` 目录中。该配置文件执行以下任务：
+ `files` 密钥在实例上创建以下文件：  
`/etc/pki/tls/certs/server.crt`  
在实例上创建证书文件。*certificate file contents*替换为证书的内容。  
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。  
`/etc/pki/tls/certs/server.key`  
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。  
`/opt/elasticbeanstalk/hooks/appdeploy/post/99_start_httpd.sh`  
创建部署后挂钩脚本以重新启动 httpd 服务。

**Example .ebextensions/https-instance.config**  

```
files:
  /etc/pki/tls/certs/server.crt:
    mode: "000400"
    owner: root
    group: root
    content: |
      -----BEGIN CERTIFICATE-----
      certificate file contents
      -----END CERTIFICATE-----
      
  /etc/pki/tls/certs/server.key:
    mode: "000400"
    owner: root
    group: root
    content: |
      -----BEGIN RSA PRIVATE KEY-----
      private key contents # See note below.
      -----END RSA PRIVATE KEY-----

  /opt/elasticbeanstalk/hooks/appdeploy/post/99_start_httpd.sh:
    mode: "000755"
    owner: root
    group: root
    content: |
      #!/usr/bin/env bash
      sudo service httpd restart
```

您还必须将环境的代理服务器配置为在端口 443 上进行侦听。以下 Apache 2.4 配置将在端口 443 上添加一个侦听器。要了解更多信息，请参阅[配置代理服务器](java-tomcat-proxy.md)。

**Example 。 ebextensions/httpd/conf.d/ssl.conf**  

```
Listen 443
<VirtualHost *:443> 
  ServerName server-name
  SSLEngine on 
  SSLCertificateFile "/etc/pki/tls/certs/server.crt" 
  SSLCertificateKeyFile "/etc/pki/tls/certs/server.key" 

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

  ErrorLog /var/log/httpd/elasticbeanstalk-ssl-error_log 

</VirtualHost>
```

您的证书供应商可能包含中间证书，可安装此证书以提高与移动客户端的兼容性。使用中间证书颁发机构 (CA) 捆绑配置 Apache，方法是将以下内容添加到您的 SSL 配置文件 (如需了解位置，请参阅[扩展并覆盖默认 Apache 配置 — 亚马逊 Linux AMI () AL1](java-tomcat-proxy.md#java-tomcat-proxy-apache))：
+ 在 `ssl.conf` 文件内容中，指定链文件：

  ```
  SSLCertificateKeyFile "/etc/pki/tls/certs/server.key"
  SSLCertificateChainFile "/etc/pki/tls/certs/gd_bundle.crt"
  SSLCipherSuite        EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH
  ```
+ 使用中间证书的内容向 `files` 密钥添加新条目：

  ```
  files:
    /etc/pki/tls/certs/gd_bundle.crt:
      mode: "000400"
      owner: root
      group: root
      content: |
        -----BEGIN CERTIFICATE-----
        First intermediate certificate
        -----END CERTIFICATE-----
        -----BEGIN CERTIFICATE-----
        Second intermediate certificate
        -----END CERTIFICATE-----
  ```

**注意**  
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。

在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。

**Example .ebextensions/ .config https-instance-single**  

```
Resources:
  sslSecurityGroupIngress: 
    Type: AWS::EC2::SecurityGroupIngress
    Properties:
      GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
      IpProtocol: tcp
      ToPort: 443
      FromPort: 443
      CidrIp: 0.0.0.0/0
```

对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end

# 在运行 .NET Core on Linux 的 Amazon EC2 实例上终止 HTTPS
<a name="https-singleinstance-dotnet-linux"></a>

对于 .NET Core on Linux 容器类型，您可以使用 `.ebextensions`[配置文件](ebextensions.md)和 nginx 配置文件（用于配置 nginx 服务器以使用 HTTPS）来启用 HTTPS。

将以下代码段添加到您的配置文件中，按照提示替换证书和私有密钥占位符，并将该文件保存在 `.ebextensions` 目录中。该配置文件执行以下任务：
+ `files` 密钥在实例上创建以下文件：  
`/etc/pki/tls/certs/server.crt`  
在实例上创建证书文件。*certificate file contents*替换为证书的内容。  
YAML 依赖一致的缩进。当替换示例配置文件中的内容时，应匹配缩进级别，并且确保您的文本编辑器使用空格而不是字符来进行缩进。
如果您有中间证书，请将其放入 `server.crt` 中您的站点证书的后面：  

  ```
        -----BEGIN CERTIFICATE-----
    certificate file contents
    -----END CERTIFICATE-----
    -----BEGIN CERTIFICATE-----
    first intermediate certificate
    -----END CERTIFICATE-----
    -----BEGIN CERTIFICATE-----
    second intermediate certificate
    -----END CERTIFICATE-----
  ```  
`/etc/pki/tls/certs/server.key`  
在实例上创建私有密钥文件。*private key contents*替换为用于创建证书请求或自签名证书的私钥内容。

**Example .ebextensions/https-instance.config**  

```
files:
  /etc/pki/tls/certs/server.crt:
    content: |
      -----BEGIN CERTIFICATE-----
      certificate file contents
      -----END CERTIFICATE-----
      
  /etc/pki/tls/certs/server.key:
    content: |      
      -----BEGIN RSA PRIVATE KEY-----
      private key contents # See note below.
      -----END RSA PRIVATE KEY-----
```

**注意**  
避免将包含私有密钥的配置文件提交到源控件。在测试完配置并确认其有效后，请在 Amazon S3 中存储私有密钥并修改配置以在部署期间下载该密钥。有关说明，请参阅[在 Amazon S3 中安全地存储私有密钥](https-storingprivatekeys.md)。

将以下内容放置在源代码包的 `.platform/nginx/conf.d/` 目录内扩展名为 `.conf` 的文件中（例如 `.platform/nginx/conf.d/https.conf`）。*app\$1port*替换为应用程序监听的端口号。此示例配置 nginx 服务器使用 SSL 侦听端口 443。有关 .NET Core on Linux 平台上的这些配置文件的更多信息，请参阅[配置代理服务器](dotnet-linux-platform-nginx.md)。

**Example 。 platform/nginx/conf.d/https.conf**  

```
# HTTPS server

server {
    listen       443 ssl;
    server_name  localhost;
    
    ssl_certificate      /etc/pki/tls/certs/server.crt;
    ssl_certificate_key  /etc/pki/tls/certs/server.key;
    
    ssl_session_timeout  5m;
    
    ssl_protocols  TLSv1 TLSv1.1 TLSv1.2;
    ssl_prefer_server_ciphers   on;
    
    location / {
        proxy_pass  http://localhost:app_port;
        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;
        proxy_set_header        X-Forwarded-Proto https;
    }
}
```

在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。

**Example .ebextensions/ .config https-instance-single**  

```
Resources:
  sslSecurityGroupIngress: 
    Type: AWS::EC2::SecurityGroupIngress
    Properties:
      GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
      IpProtocol: tcp
      ToPort: 443
      FromPort: 443
      CidrIp: 0.0.0.0/0
```

对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end

# 在运行.NET 的亚马逊 EC2 实例上终止 HTTPS
<a name="SSLNET.SingleInstance"></a>

以下[配置文件](ebextensions.md)创建并运行用于执行以下任务的 Windows PowerShell 脚本：
+ 检查现有 HTTPS 证书是否已绑定到端口 443。
+ 从 Amazon S3 存储桶获取 [PFX 证书](configuring-https-ssl.md)。
**注意**  
向 `aws-elasticbeanstalk-ec2-role` 添加 `AmazonS3ReadOnlyAccess` 策略，以访问 Amazon S3 存储桶中的 SSL 证书。
+ 从中获取密码 AWS Secrets Manager。
**注意**  
在 `aws-elasticbeanstalk-ec2-role` 中添加一条语句，以允许对包含证书密码的密钥执行 `secretsmanager:GetSecretValue` 操作
+ 安装证书。
+ 将证书绑定到端口 443。
**注意**  
要删除 HTTP 终端节点（端口 80），请在示例的**删除 HTTP 绑定** 部分中包括 `Remove-WebBinding` 命令。

**Example .ebextensions/ .config https-instance-dotnet**  

```
files:
  "C:\\certs\\install-cert.ps1":
    content: |
      import-module webadministration
      ## Settings - replace the following values with your own
      $bucket = "amzn-s3-demo-bucket"  ## S3 bucket name
      $certkey = "example.com.pfx"    ## S3 object key for your PFX certificate
      $secretname = "example_secret"  ## AWS Secrets Manager name for a secret that contains the certificate's password
      ##

      # Set variables
      $certfile = "C:\cert.pfx"
      $pwd = Get-SECSecretValue -SecretId $secretname | select -expand SecretString

      # Clean up existing binding
      if ( Get-WebBinding "Default Web Site" -Port 443 ) {
        Echo "Removing WebBinding"
        Remove-WebBinding -Name "Default Web Site" -BindingInformation *:443:
      }
      if ( Get-Item -path IIS:\SslBindings\0.0.0.0!443 ) {
        Echo "Deregistering WebBinding from IIS"
        Remove-Item -path IIS:\SslBindings\0.0.0.0!443
      }

      # Download certificate from S3
      Read-S3Object -BucketName $bucket -Key $certkey -File $certfile
      
      # Install certificate
      Echo "Installing cert..."
      $securepwd = ConvertTo-SecureString -String $pwd -Force -AsPlainText
      $cert = Import-PfxCertificate -FilePath $certfile cert:\localMachine\my -Password $securepwd
      
      # Create site binding
      Echo "Creating and registering WebBinding"
      New-WebBinding -Name "Default Web Site" -IP "*" -Port 443 -Protocol https
      New-Item -path IIS:\SslBindings\0.0.0.0!443 -value $cert -Force
      
      ## Remove the HTTP binding
      ## (optional) Uncomment the following line to unbind port 80
      # Remove-WebBinding -Name "Default Web Site" -BindingInformation *:80:
      ##
      
      # Update firewall
      netsh advfirewall firewall add rule name="Open port 443" protocol=TCP localport=443 action=allow dir=OUT

commands:
  00_install_ssl:
    command: powershell -NoProfile -ExecutionPolicy Bypass -file C:\\certs\\install-cert.ps1
```

在单实例环境中，您还必须修改实例的安全组，以便允许端口 443 上的流量。以下配置文件使用 CloudFormation [函数](ebextensions-functions.md)检索安全组的 ID 并向其添加规则。

**Example .ebextensions/ .config https-instance-single**  

```
Resources:
  sslSecurityGroupIngress: 
    Type: AWS::EC2::SecurityGroupIngress
    Properties:
      GroupId: {"Fn::GetAtt" : ["AWSEBSecurityGroup", "GroupId"]}
      IpProtocol: tcp
      ToPort: 443
      FromPort: 443
      CidrIp: 0.0.0.0/0
```

对于负载平衡的环境，您可以将负载均衡器配置为要么[原封不动地传递安全流量，要么解密并重新加密以进行](https-tcp-passthrough.md)[加密](configuring-https-endtoend.md)。 end-to-end