Visão geral do 1: Pré-requisitos 2: Gerar chave e certificado 3: Configurar o servidor web 4: Verificar

AWS CloudHSM SSL/TLS descarregar no Linux usando NGINX ou HAProxy com OpenSSL Provider

Este tópico fornece instruções passo a passo para configurar o descarregamento de identidade SSL/TLS do servidor AWS CloudHSM em um servidor web Linux usando NGINX ou HAProxy com o provedor OpenSSL.

Tópicos

Visão geral do
Etapa 1: configurar os pré-requisitos
Etapa 2: gerar ou importar uma chave privada e obter um certificado
Etapa 3: configure o servidor Web
Etapa 4: permitir tráfego HTTPS e verificar o certificado

Visão geral do

No Linux, o software de servidor web NGINX e HAProxy se integra ao OpenSSL para oferecer suporte a HTTPS. O provedor AWS CloudHSM OpenSSL fornece uma interface que permite que o software do servidor web use os HSMs em seu cluster para transferência criptográfica e armazenamento de chaves. O provedor OpenSSL é a ponte que conecta o servidor web ao seu AWS CloudHSM cluster.

Para concluir este tutorial, você configurará o NGINX ou o HAProxy para usar o AWS CloudHSM provedor OpenSSL. O tutorial mostra como fazer o seguinte:

Instale o software do servidor Web em uma instância do Amazon EC2.
Configure o software do servidor Web para oferecer suporte a HTTPS com uma chave privada armazenada em seu AWS CloudHSM cluster.
(Opcional) Use o Amazon EC2 para criar uma segunda instância de servidor Web e o Elastic Load Balancing para criar um balanceador de carga. Usar um load balanceador de carga pode aumentar o desempenho, distribuindo a carga em vários servidores. Ele também pode fornecer redundância e maior disponibilidade se um ou mais servidores falhar.

Quando estiver pronto para começar, vá para Etapa 1: configurar os pré-requisitos.

Etapa 1: configurar os pré-requisitos

Plataformas diferentes exigem pré-requisitos diferentes. Use a seção de pré-requisitos abaixo que corresponde à sua plataforma.

Pré-requisitos para AWS CloudHSM Provedor OpenSSL

Para configurar o descarregamento de identidade SSL/TLS do servidor web com o AWS CloudHSM OpenSSL Provider for Client SDK 5, você precisa do seguinte:

Um AWS CloudHSM cluster ativo com pelo menos dois módulos de segurança de hardware (HSM)

nota
Você pode usar um único cluster HSM, mas primeiro deve desativar a durabilidade da chave do cliente. Para obter mais informações, consulte Gerenciar configurações de durabilidade da chave do cliente e Ferramenta de configuração do Client SDK 5.
Uma instância do Amazon EC2 executando um sistema operacional Linux com o seguinte software instalado:
- Um servidor web (NGINX ou HAProxy)
- O provedor AWS CloudHSM OpenSSL para o cliente SDK 5
Um usuário de criptografia (CU) para ter e gerenciar a chave privada do servidor Web no HSM.

Para configurar uma instância do servidor web do Linux e criar um CU no HSM

nota

Muitos dos comandos desse procedimento exigem privilégios elevados. Talvez seja necessário executar comandos com sudo ou como usuário root, dependendo da configuração do sistema.

Instale e configure o AWS CloudHSM OpenSSL Provider para o Client SDK 5. Para obter mais informações sobre a instalação do OpenSSL Provider, consulte AWS CloudHSM OpenSSL Provider for Client SDK 5.
Em uma instância Linux do EC2 que tenha acesso ao seu cluster, instale o servidor web NGINX ou HAProxy:
Amazon Linux 2023
NGINX

$ yum install nginx

HAProxy

$ yum install haproxy
RHEL 9 (9.2+)
NGINX

$ yum install nginx

HAProxy

$ yum install haproxy
RHEL 10 (10.0+)
NGINX

$ yum install nginx

HAProxy

$ yum install haproxy
Ubuntu 26.04 LTS
NGINX

$ apt install nginx

HAProxy

$ apt install haproxy
Use a CloudHSM CLI para criar um usuário de criptografia. Para obter mais informações sobre o gerenciamento de usuários do HSM, consulte Gerenciar usuários do HSM com a CLI do CloudHSM.

dica
Lembre o nome do usuário e a senha do CU. Eles serão necessários mais tarde ao gerar ou importar a chave privada HTTPS e o certificado para o servidor Web.

Depois de concluir essas etapas, vá para Etapa 2: gerar ou importar uma chave privada e obter um certificado.

Observações

Para usar Security-Enhanced Linux (SELinux) e servidores web, você deve permitir conexões TCP de saída na porta 2223, que é a porta que o Client SDK 5 usa para se comunicar com o HSM.
Para criar e ativar um cluster e dar acesso a uma instância do EC2 ao cluster, conclua as etapas em Conceitos básicos de AWS CloudHSM. Os conceitos básicos oferecem instruções passo a passo para criar um cluster ativo com um HSM e uma instância de cliente do Amazon EC2. Você pode usar essa instância de cliente como seu servidor Web.
Para evitar a desativação da durabilidade da chave do cliente, adicione mais de um HSM ao seu cluster. Para obter mais informações, consulte Adicionando um HSM a um AWS CloudHSM cluster.
Você pode usar um cliente SSH ou PuTTY para se conectar à instância do cliente. Para obter mais informações, consulte Conectar à instância Linux utilizando SSH ou Conectar à instância Linux no Windows utilizando PuTTY na documentação do Amazon C2.

Etapa 2: gerar ou importar uma chave privada e obter um certificado

Para habilitar HTTPS, seu aplicativo de servidor web (NGINX ou HAProxy) precisa de uma chave privada e de um certificado correspondente. SSL/TLS Para usar o descarregamento de identidade SSL/TLS do servidor web com AWS CloudHSM, você deve armazenar a chave privada em um HSM em seu AWS CloudHSM cluster. Crie uma chave privada e use a chave para criar uma solicitação de assinatura de certificado (CSR). Você exporta uma chave privada PEM falsa do HSM, que é um arquivo de chave privada no formato PEM que contém uma referência à chave privada armazenada no HSM (não é a chave privada real). Seu servidor web usa o falso arquivo de chave privada PEM para identificar a chave privada no HSM durante o descarregamento da identidade SSL/TLS do servidor.

Gerar uma chave privada

Esta seção mostra como gerar um par de chaves usando o CloudHSM CLI. Depois de gerar um par de chaves dentro do HSM, você pode exportá-lo como um arquivo PEM falso e gerar o certificado correspondente.

Instalar e configurar a CloudHSM CLI

Instale e configure a CloudHSM CLI.
Use o comando a seguir para iniciar a CloudHSM CLI.
```
$ /opt/cloudhsm/bin/cloudhsm-cli interactive
```
Execute o seguinte comando para fazer login no HSM. <user name>Substitua pelo nome de usuário do seu criptousuário
```
aws-cloudhsm>login --username <user name> --role crypto-user
```

Gerar uma chave privada

Dependendo do seu caso de uso, você pode gerar um RSA ou um par de chaves EC. Você também pode gerar um Ed25519 ou par de ML-DSA chaves para uso com o TLS 1.3. Execute um destes procedimentos:

Para gerar uma chave privada RSA em um HSM

Use o comando key generate-asymmetric-pair rsa para gerar um par de chaves RSA. Este exemplo gera um par de chaves RSA com um módulo de 2048, um expoente público de 65537, rótulo de chave pública de e rótulo de chave privada detls_rsa_pub. tls_rsa_private


aws-cloudhsm > key generate-asymmetric-pair rsa \
--public-exponent 65537 \
--modulus-size-bits 2048 \
--public-label tls_rsa_pub \
--private-label tls_rsa_private \
--private-attributes sign=true
{
  "error_code": 0,
  "data": {
    "public_key": {
      "key-reference": "0x0000000000280cc8",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "rsa",
        "label": "tls_rsa_pub",
        "id": "",
        "check-value": "0x01fe6e",
        "class": "public-key",
        "encrypt": true,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": true,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": false,
        "sign": false,
        "trusted": false,
        "unwrap": false,
        "verify": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 512,
        "public-exponent": "0x010001",
        "modulus": "0xb1d27e857a876f4e9fd5de748a763c539b359f937eb4b4260e30d1435485a732c878cdad9c72538e2215351b1d41358c9bf80b599c73a80fdb457aa7b20cd61e486c326e2cfd5e124a7f6a996437437812b542e3caf85928aa866f0298580f7967ee6aa01440297d7308fdd9b76b70d1b67f12634df6e6296d6c116d5744c6d60d14d3bf3cb978fe6b75ac67b7089bafd50d8687213b31abc7dc1bad422780d29c851d5102b56f932551eaf52a9591fd8c43d81ecc133022653225bd129f8491101725e9ea33e1ded83fb57af35f847e532eb30cd7e726f23910d2671c6364092e834697ec3cef72cc23615a1ba7c5e100156ae0acac3160f0ca9725d38318b7",
        "modulus-size-bits": 2048
      }
    },
    "private_key": {
      "key-reference": "0x0000000000280cc7",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "rsa",
        "label": "tls_rsa_private",
        "id": "",
        "check-value": "0x01fe6e",
        "class": "private-key",
        "encrypt": false,
        "decrypt": true,
        "token": true,
        "always-sensitive": true,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": true,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 1217,
        "public-exponent": "0x010001",
        "modulus": "0xb1d27e857a876f4e9fd5de748a763c539b359f937eb4b4260e30d1435485a732c878cdad9c72538e2215351b1d41358c9bf80b599c73a80fdb457aa7b20cd61e486c326e2cfd5e124a7f6a996437437812b542e3caf85928aa866f0298580f7967ee6aa01440297d7308fdd9b76b70d1b67f12634df6e6296d6c116d5744c6d60d14d3bf3cb978fe6b75ac67b7089bafd50d8687213b31abc7dc1bad422780d29c851d5102b56f932551eaf52a9591fd8c43d81ecc133022653225bd129f8491101725e9ea33e1ded83fb57af35f847e532eb30cd7e726f23910d2671c6364092e834697ec3cef72cc23615a1ba7c5e100156ae0acac3160f0ca9725d38318b7",
        "modulus-size-bits": 2048
      }
    }
  }
}

Para gerar uma chave privada EC em um HSM

Use o comando key generate-asymmetric-pair ec para gerar um par de chaves EC. Este exemplo gera um par de chaves EC com a prime256v1 curva (correspondente à NID_X9_62_prime256v1 curva), um rótulo de chave pública de tls_ec_pub e um rótulo de chave privada detls_ec_private.


aws-cloudhsm > key generate-asymmetric-pair ec \
    --curve prime256v1 \
    --public-label tls_ec_pub \
    --private-label tls_ec_private \
    --private-attributes sign=true
{
  "error_code": 0,
  "data": {
    "public_key": {
      "key-reference": "0x000000000012000b",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "cluster-coverage": "session"
      },
      "attributes": {
        "key-type": "ec",
        "label": "tls_ec_pub",
        "id": "",
        "check-value": "0xd7c1a7",
        "class": "public-key",
        "encrypt": false,
        "decrypt": false,
        "token": false,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": true,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": false,
        "sign": false,
        "trusted": false,
        "unwrap": false,
        "verify": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 57,
        "ec-point": "0x047096513df542250a6b228fd9cb67fd0c903abc93488467681974d6f371083fce1d79da8ad1e9ede745fb9f38ac8622a1b3ebe9270556000c",
        "curve": "secp224r1"
      }
    },
"private_key": {
      "key-reference": "0x000000000012000c",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "cluster-coverage": "session"
      },
      "attributes": {
        "key-type": "ec",
        "label": "tls_ec_private",
        "id": "",
        "check-value": "0xd7c1a7",
        "class": "private-key",
        "encrypt": false,
        "decrypt": false,
        "token": false,
        "always-sensitive": true,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": true,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 122,
        "ec-point": "0x047096513df542250a6b228fd9cb67fd0c903abc93488467681974d6f371083fce1d79da8ad1e9ede745fb9f38ac8622a1b3ebe9270556000c",
        "curve": "secp224r1"
      }
    }
  }
}

Para gerar uma chave privada Ed25519 em um HSM

Ed25519: disponibilidade

O Ed25519 só está disponível em clusters não FIPS. O Ed25519 suporta somente TLS 1.3.

Use o key generate-asymmetric-pair ec comando para gerar um par de chaves Ed25519. Este exemplo gera um par de chaves Ed25519 com um rótulo de chave pública de tls_ed25519_pub e um rótulo de chave privada de. tls_ed25519_private


aws-cloudhsm > key generate-asymmetric-pair ec \
    --curve ed25519 \
    --public-label tls_ed25519_pub \
    --private-label tls_ed25519_private \
    --private-attributes sign=true \
    --public-attributes verify=true
{
  "error_code": 0,
  "data": {
    "public_key": {
      "key-reference": "0x0000000000383931",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "ec",
        "label": "tls_ed25519_pub",
        "id": "0x",
        "check-value": "0x4cb1b1",
        "class": "public-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": true,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": false,
        "sign": false,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 32,
        "ec-point": "0x302a300506032b6570032100c31f8a3695f571dda1658bc98e0591ab088c1a657b3199dd50c3956046ebbe75",
        "curve": "ed25519"
      }
    },
    "private_key": {
      "key-reference": "0x0000000000382e60",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "ec",
        "label": "tls_ed25519_private",
        "id": "0x",
        "check-value": "0x4cb1b1",
        "class": "private-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": true,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": true,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 48,
        "ec-point": "0x302a300506032b6570032100c31f8a3695f571dda1658bc98e0591ab088c1a657b3199dd50c3956046ebbe75",
        "curve": "ed25519"
      }
    }
  }
}

Para gerar uma chave ML-DSA privada em um HSM

ML-DSA disponibilidade e requisitos

ML-DSA está disponível somente em clusters não FIPS e requer o OpenSSL 3.5 ou posterior para criação de CSR, criação de certificados e descarregamento de TLS. ML-DSA suporta somente TLS 1.3.

Para o descarregamento de ML-DSA TLS nas plataformas Amazon Linux 2023 e RHEL, talvez seja necessário habilitar a subpolítica de criptografia pós-quântica (PQ). Para obter mais informações, consulte Problema: o handshake ML-DSA TLS falha no Amazon Linux 2023 e no RHEL sem “algoritmos de assinatura compartilhada”.

Use o key generate-asymmetric-pair ml-dsa comando para gerar um par de ML-DSA chaves. Este exemplo gera um par de ML-DSA-44 chaves com um rótulo de chave pública de tls_mldsa44_pub e um rótulo de chave privada detls_mldsa44_private. Você também pode usar ML-DSA-65 ou ML-DSA-87 para obter níveis de segurança mais altos.


aws-cloudhsm > key generate-asymmetric-pair ml-dsa \
    --mldsa-algorithm ML-DSA-44 \
    --public-label tls_mldsa44_pub \
    --private-label tls_mldsa44_private \
    --private-attributes sign=true \
    --public-attributes verify=true
{
  "error_code": 0,
  "data": {
    "public_key": {
      "key-reference": "0x0000000000280cd2",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "ml-dsa",
        "label": "tls_mldsa44_pub",
        "id": "",
        "check-value": "0xd4e5f6",
        "class": "public-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": true,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": false,
        "sign": false,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 1312,
        "mldsa-algorithm": "ML-DSA-44"
      }
    },
    "private_key": {
      "key-reference": "0x0000000000280cd3",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "ml-dsa",
        "label": "tls_mldsa44_private",
        "id": "",
        "check-value": "0xd4e5f6",
        "class": "private-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": true,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": true,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 2560,
        "mldsa-algorithm": "ML-DSA-44"
      }
    }
  }
}

Exportar um arquivo de chave privada PEM falso

Depois de ter uma chave privada no HSM, você deve exportar um arquivo de chave privada PEM falso. Esse arquivo não contém os dados reais da chave, mas permite que o provedor OpenSSL identifique a chave privada no HSM. Em seguida, você pode usar a chave privada para criar uma solicitação de assinatura de certificado (CSR) e assinar a CSR para criar o certificado.

Execute o comando key generate-file para exportar a chave privada no formato PEM falso e salvá-lo em um arquivo. Substitua os seguintes valores pelo seu próprio.

<private_key_label>— Etiqueta da chave privada que você gerou na etapa anterior.
<web_server_fake_pem.key>— Nome do arquivo no qual sua chave PEM falsa será gravada.

Para chaves RSA e EC

Use a reference-pem codificação:


aws-cloudhsm > key generate-file --encoding reference-pem --path <web_server_fake_pem.key> --filter attr.label=<private_key_label>
{
  "error_code": 0,
  "data": {
    "message": "Successfully generated key file"
  }
}

Para Ed25519 e chaves ML-DSA

Use a cloudhsm-reference-pem codificação:


aws-cloudhsm > key generate-file --encoding cloudhsm-reference-pem --path <web_server_fake_pem.key> --filter attr.label=<private_key_label>
{
  "error_code": 0,
  "data": {
    "message": "Successfully generated key file"
  }
}

Saia da CloudHSM CLI

Execute o comando a seguir para parar a CloudHSM CLI.


aws-cloudhsm > quit

Agora você deve ter um novo arquivo em seu sistema, localizado no caminho especificado pelo <web_server_fake_pem.key> comando anterior. Esse arquivo é o arquivo de chave privada PEM falso.

Gere um certificado autoassinado

Depois de gerar uma chave privada PEM falsa, você pode usar esse arquivo para gerar uma solicitação de assinatura de certificado (CSR) e um certificado.

Em um ambiente de produção, geralmente usa-se uma autoridade de certificação (CA) para criar um certificado de uma CSR. Não é necessária uma CA para um ambiente de teste. Se você usar uma CA, envie o arquivo CSR para eles e use o SSL/TLS certificado assinado que eles fornecem em seu servidor web para HTTPS.

Como alternativa ao uso de uma CA, você pode usar o provedor AWS CloudHSM OpenSSL para criar um certificado autoassinado. Self-signed os certificados não são confiáveis para os navegadores e não devem ser usados em ambientes de produção. Eles podem ser usados em ambientes de teste.

Atenção

Self-signed os certificados devem ser usados somente em um ambiente de teste. Para um ambiente de produção, use um método mais seguro, como uma autoridade de certificação, para criar um certificado.

Instalar e configurar o provedor OpenSSL

Conecte-se à instância do cliente.
Instale o provedor OpenSSL para AWS CloudHSM Client SDK 5

Gere um certificado

Obtenha uma cópia do arquivo PEM falso gerado em uma etapa anterior.
Crie uma CSR

Execute o comando a seguir para usar o provedor AWS CloudHSM OpenSSL para criar uma solicitação de assinatura de certificado (CSR). <web_server_fake_pem.key>Substitua pelo nome do arquivo que contém sua chave privada PEM falsa. <web_server.csr>Substitua pelo nome do arquivo que contém sua CSR.

O comando req é interativo. Responda a cada campo. As informações do campo são copiadas em seu SSL/TLS certificado.

ML-DSA Requisito de versão do OpenSSL
ML-DSA requer OpenSSL 3.5 ou posterior. Em plataformas com um sistema OpenSSL mais antigo, você deve usar um binário OpenSSL 3.5+ personalizado.

Algoritmo de resumo necessário para chaves RSA e EC
Para chaves RSA e EC, você deve especificar um algoritmo de resumo (por exemplo,-sha256). Ed25519 e ML-DSA não exigem um sinalizador de resumo.
```
$ openssl req -provider cloudhsm -provider default -new -sha256 -key <web_server_fake_pem.key> -out <web_server.csr>
```
Criar um certificado autoassinado

Execute o comando a seguir para usar o provedor AWS CloudHSM OpenSSL para assinar sua CSR com sua chave privada em seu HSM. Isso cria um certificado autoassinado. Substitua os valores a seguir no comando pelos seus próprios.
- <web_server.csr>— Nome do arquivo que contém a CSR.
- <web_server_fake_pem.key>— Nome do arquivo que contém a chave privada PEM falsa.
- <web_server.crt>— Nome do arquivo que conterá seu certificado de servidor web.
```
$ openssl x509 -provider cloudhsm -provider default -req -sha256 -days 365 -in <web_server.csr> -signkey <web_server_fake_pem.key> -out <web_server.crt>
```

Depois de ter uma chave privada e um certificado, acesseEtapa 3: configure o servidor Web.

Etapa 3: configure o servidor Web

Atualize a configuração do software de servidor web para usar o certificado HTTPS e a chave privada PEM falsa correspondente que você criou na etapa anterior. Lembre-se de fazer backup de seus certificados e chaves existentes antes de começar. Isso concluirá a configuração do software do servidor web Linux para descarregar a identidade SSL/TLS do servidor com AWS CloudHSM.

Conclua as etapas de uma das seções a seguir.

Configurar o servidor da Web NGINX

Use esta seção para configurar o NGINX com o provedor OpenSSL.

Para configurar o NGINX para o provedor OpenSSL

Conecte-se à instância do cliente.
Execute o seguinte comando para criar os diretórios necessários para o certificado do servidor Web e a chave privada PEM falsa.
```
$ mkdir -p /etc/pki/nginx/private
```
Execute o seguinte comando para copiar o certificado do seu servidor Web para o local desejado. <web_server.crt>Substitua pelo nome do certificado do seu servidor web.
```
$ cp <web_server.crt> /etc/pki/nginx/server.crt
```
Execute o seguinte comando para copiar sua chave privada PEM falsa no local desejado. <web_server_fake_pem.key>Substitua pelo nome do arquivo que contém sua chave privada PEM falsa.
```
$ cp <web_server_fake_pem.key> /etc/pki/nginx/private/server.key
```
Execute o comando a seguir para alterar a propriedade dos arquivos, para que o usuário chamado nginx possa lê-los.
```
$ chown nginx /etc/pki/nginx/server.crt /etc/pki/nginx/private/server.key
```
Configure o OpenSSL para usar o AWS CloudHSM provedor. Para obter mais informações sobre como configurar o OpenSSL Provider, consulte AWS CloudHSM OpenSSL Provider for Client SDK 5.
1. Localize seu arquivo de configuração do OpenSSL:
```
$ openssl version -d
```
  O resultado exibido deve ser semelhante a:
```
OPENSSLDIR: "/etc/pki/tls"
```
  O arquivo de configuração está openssl.cnf nesse diretório.
2. nota
  Não modifique diretamente o arquivo openssl.cnf padrão do seu sistema. Isso evita que as operações OpenSSL em todo o sistema (conexões SSH, TLS e outros serviços) sejam roteadas involuntariamente pelo provedor CloudHSM.
  O uso de um arquivo de configuração separado permite que você defina o escopo do uso do CloudHSM Provider somente para aplicativos específicos que exigem operações HSM-backed criptográficas.
  
  Crie um novo arquivo de configuração do OpenSSL com o seguinte conteúdo:
```
$ cat > <example-cloudhsm-openssl.cnf> << 'EOF'
## NOTE: This should point to the system default openssl config file.
# Replace /etc/pki/tls with the path to your OpenSSL configuration directory
.include </etc/pki/tls>/openssl.cnf

# Override the existing provider_section to include AWS CloudHSM OpenSSL Provider as a 3rd party OpenSSL provider
[provider_sect]
default = default_sect
# Include AWS CloudHSM CloudHSM OpenSSL provider
cloudhsm = cloudhsm_sect

[default_sect]
activate = 1

[cloudhsm_sect]
activate = 1
EOF
```
3. Certifique-se de que a variável de CLOUDHSM_PIN ambiente esteja definida com suas credenciais de usuário criptográfico (CU):
```
$ export CLOUDHSM_PIN=<username>:<password>
```
4. Defina a variável de OPENSSL_CONF ambiente para apontar para seu arquivo de configuração atualizado e verifique se o provedor está carregado:
```
$ OPENSSL_CONF=/path/to/example-cloudhsm-openssl.cnf openssl list -providers
```
  Você deve ver o provedor padrão e o provedor do CloudHSM listados:
```
OPENSSL_CONF=/path/to/example-cloudhsm-openssl.cnf openssl list -providers
Providers:
  default
    name: OpenSSL Default Provider
    version: 3.2.2
    status: active
  cloudhsm
    name: AWS CloudHSM OpenSSL Provider
    version: 5.17.0
    status: active
```
Execute o comando a seguir para fazer backup do arquivo /etc/nginx/nginx.conf.
```
$ cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.backup
```

Atualizar a configuração para NGINX.

nota

Cada cluster pode suportar no máximo 1000 processos de trabalho do NGINX em todos os servidores Web do NGINX.

Amazon Linux 2023

Use um editor de texto para editar o arquivo /etc/nginx/nginx.conf. Isso pode exigir permissões de root do Linux. Na parte superior do arquivo, adicione as seguintes linhas:


env CLOUDHSM_PIN;
env OPENSSL_CONF;

Em seguida, adicione o seguinte à seção TLS do arquivo:


# Settings for a TLS enabled server.
server {
    listen       443 ssl http2 default_server;
    listen       [::]:443 ssl http2 default_server;
    server_name  _;
    root         /usr/share/nginx/html;

    ssl_certificate "/etc/pki/nginx/server.crt";
    ssl_certificate_key "/etc/pki/nginx/private/server.key";
    # It is *strongly* recommended to generate unique DH parameters for DHE ciphers
    # Generate them with: openssl dhparam -out /etc/pki/nginx/dhparams.pem 2048
    # ssl_dhparam "/etc/pki/nginx/dhparams.pem";
    ssl_session_cache shared:SSL:1m;
    ssl_session_timeout  10m;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256";
    ssl_prefer_server_ciphers off;

    # Load configuration files for the default server block.
    include /etc/nginx/default.d/*.conf;

    location / {
    }

    error_page 404 /404.html;
    location = /40x.html {
    }

    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
    }
}

RHEL 9 (9.2+)

Use um editor de texto para editar o arquivo /etc/nginx/nginx.conf. Isso pode exigir permissões de root do Linux. Na parte superior do arquivo, adicione as seguintes linhas:


env CLOUDHSM_PIN;
env OPENSSL_CONF;

Em seguida, adicione o seguinte à seção TLS do arquivo:


# Settings for a TLS enabled server.
server {
    listen       443 ssl http2 default_server;
    listen       [::]:443 ssl http2 default_server;
    server_name  _;
    root         /usr/share/nginx/html;

    ssl_certificate "/etc/pki/nginx/server.crt";
    ssl_certificate_key "/etc/pki/nginx/private/server.key";
    # It is *strongly* recommended to generate unique DH parameters for DHE ciphers
    # Generate them with: openssl dhparam -out /etc/pki/nginx/dhparams.pem 2048
    # ssl_dhparam "/etc/pki/nginx/dhparams.pem";
    ssl_session_cache shared:SSL:1m;
    ssl_session_timeout  10m;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256";
    ssl_prefer_server_ciphers off;

    # Load configuration files for the default server block.
    include /etc/nginx/default.d/*.conf;

    location / {
    }

    error_page 404 /404.html;
    location = /40x.html {
    }

    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
    }
}

RHEL 10 (10.0+)

Use um editor de texto para editar o arquivo /etc/nginx/nginx.conf. Isso pode exigir permissões de root do Linux. Na parte superior do arquivo, adicione as seguintes linhas:


env CLOUDHSM_PIN;
env OPENSSL_CONF;

Em seguida, adicione o seguinte à seção TLS do arquivo:


# Settings for a TLS enabled server.
server {
    listen       443 ssl http2 default_server;
    listen       [::]:443 ssl http2 default_server;
    server_name  _;
    root         /usr/share/nginx/html;

    ssl_certificate "/etc/pki/nginx/server.crt";
    ssl_certificate_key "/etc/pki/nginx/private/server.key";
    # It is *strongly* recommended to generate unique DH parameters for DHE ciphers
    # Generate them with: openssl dhparam -out /etc/pki/nginx/dhparams.pem 2048
    # ssl_dhparam "/etc/pki/nginx/dhparams.pem";
    ssl_session_cache shared:SSL:1m;
    ssl_session_timeout  10m;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256";
    ssl_prefer_server_ciphers off;

    # Load configuration files for the default server block.
    include /etc/nginx/default.d/*.conf;

    location / {
    }

    error_page 404 /404.html;
    location = /40x.html {
    }

    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
    }
}

Ubuntu 26.04 LTS

Use um editor de texto para editar o arquivo /etc/nginx/nginx.conf. Isso pode exigir permissões de root do Linux. Na parte superior do arquivo, adicione as seguintes linhas:


env CLOUDHSM_PIN;
env OPENSSL_CONF;

Em seguida, adicione o seguinte à seção TLS do arquivo:


# Settings for a TLS enabled server.
server {
    listen       443 ssl http2 default_server;
    listen       [::]:443 ssl http2 default_server;
    server_name  _;
    root         /var/www/html;

    ssl_certificate "/etc/ssl/certs/server.crt";
    ssl_certificate_key "/etc/ssl/private/server.key";
    # It is *strongly* recommended to generate unique DH parameters for DHE ciphers
    # Generate them with: openssl dhparam -out /etc/ssl/certs/dhparams.pem 2048
    # ssl_dhparam "/etc/ssl/certs/dhparams.pem";
    ssl_session_cache shared:SSL:1m;
    ssl_session_timeout  10m;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256";
    ssl_prefer_server_ciphers off;

    # Load configuration files for the default server block.
    include /etc/nginx/default.d/*.conf;

    location / {
    }

    error_page 404 /404.html;
    location = /40x.html {
    }

    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
    }
}

Salve o arquivo.

Faça o backup do arquivo de configuração systemd e defina o caminho EnvironmentFile.
Amazon Linux 2023
Faça backup do nginx.service arquivo:

$ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup

Abra /lib/systemd/system/nginx.service em um editor de texto. Na seção [Serviço], adicione:

EnvironmentFile=/etc/sysconfig/nginx
RHEL 9 (9.2+)
Faça backup do nginx.service arquivo:

$ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup

Abra /lib/systemd/system/nginx.service em um editor de texto. Na seção [Serviço], adicione:

EnvironmentFile=/etc/sysconfig/nginx
RHEL 10 (10.0+)
Faça backup do nginx.service arquivo:

$ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup

Abra /lib/systemd/system/nginx.service em um editor de texto. Na seção [Serviço], adicione:

EnvironmentFile=/etc/sysconfig/nginx
Ubuntu 26.04 LTS
Faça backup do nginx.service arquivo:

$ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup

Abra /lib/systemd/system/nginx.service em um editor de texto. Na seção [Serviço], adicione:

EnvironmentFile=/etc/sysconfig/nginx
Verifique se o arquivo /etc/sysconfig/nginx existe e siga um destes procedimentos:
- Se o arquivo existir, faça backup do arquivo executando o seguinte comando:
```
$ cp /etc/sysconfig/nginx /etc/sysconfig/nginx.backup
```
- Se o arquivo não existir, abra um editor de texto e crie um arquivo chamado nginx na pasta /etc/sysconfig/.
Configure o ambiente NGINX.
Amazon Linux 2023
Como usuário-raiz do Linux, abra o arquivo /etc/sysconfig/nginx em um editor de texto. Por exemplo,
```
vi /etc/sysconfig/nginx
```
Adicione as credenciais do Usuário de Criptografia (CU) e o caminho para seu arquivo de configuração do OpenSSL:
```
CLOUDHSM_PIN=<CU user name>:<password>
OPENSSL_CONF=<path to example-cloudhsm-openssl.cnf>
```
Substitua <CU user name> e <password> pelas credenciais da UC. <path to example-cloudhsm-openssl.cnf>Substitua pelo caminho completo para o arquivo de configuração que você criou emPara configurar o NGINX para o provedor OpenSSL.

Salve o arquivo.
RHEL 9 (9.2+)
Abra o arquivo /etc/sysconfig/nginx em um editor de textos. Isso pode exigir permissões de root do Linux. Adicione as credenciais do Usuário de Criptografia (CU) e o caminho para seu arquivo de configuração do OpenSSL:
```
CLOUDHSM_PIN=<CU user name>:<password>
OPENSSL_CONF=<path to example-cloudhsm-openssl.cnf>
```
Substitua <CU user name> e <password> pelas credenciais da UC. <path to example-cloudhsm-openssl.cnf>Substitua pelo caminho completo para o arquivo de configuração que você criou emPara configurar o NGINX para o provedor OpenSSL.

Salve o arquivo.
RHEL 10 (10.0+)
Abra o arquivo /etc/sysconfig/nginx em um editor de textos. Isso pode exigir permissões de root do Linux. Adicione as credenciais do Usuário de Criptografia (CU) e o caminho para seu arquivo de configuração do OpenSSL:
```
CLOUDHSM_PIN=<CU user name>:<password>
OPENSSL_CONF=<path to example-cloudhsm-openssl.cnf>
```
Substitua <CU user name> e <password> pelas credenciais da UC. <path to example-cloudhsm-openssl.cnf>Substitua pelo caminho completo para o arquivo de configuração que você criou emPara configurar o NGINX para o provedor OpenSSL.

Salve o arquivo.
Ubuntu 26.04 LTS
Abra o arquivo /etc/sysconfig/nginx em um editor de textos. Isso pode exigir permissões de root do Linux. Adicione as credenciais do Usuário de Criptografia (CU) e o caminho para seu arquivo de configuração do OpenSSL:
```
CLOUDHSM_PIN=<CU user name>:<password>
OPENSSL_CONF=<path to example-cloudhsm-openssl.cnf>
```
Substitua <CU user name> e <password> pelas credenciais da UC. <path to example-cloudhsm-openssl.cnf>Substitua pelo caminho completo para o arquivo de configuração que você criou emPara configurar o NGINX para o provedor OpenSSL.

Salve o arquivo.
Inicie o servidor web NGINX.
Amazon Linux 2023
Parar todos os processos do NGINX
```
$ systemctl stop nginx
```
Recarregue a configuração systemd para receber as alterações mais recentes
```
$ systemctl daemon-reload
```
Iniciar o NGINX
```
$ systemctl start nginx
```
RHEL 9 (9.2+)
Pare qualquer processo NGINX em execução
```
$ systemctl stop nginx
```
Recarregue a configuração systemd para receber as alterações mais recentes
```
$ systemctl daemon-reload
```
Inicie o processo NGINX
```
$ systemctl start nginx
```
RHEL 10 (10.0+)
Pare qualquer processo NGINX em execução
```
$ systemctl stop nginx
```
Recarregue a configuração systemd para receber as alterações mais recentes
```
$ systemctl daemon-reload
```
Inicie o processo NGINX
```
$ systemctl start nginx
```
Ubuntu 26.04 LTS
Pare qualquer processo NGINX em execução
```
$ systemctl stop nginx
```
Recarregue a configuração systemd para receber as alterações mais recentes
```
$ systemctl daemon-reload
```
Inicie o processo NGINX
```
$ systemctl start nginx
```

Depois de configurar o NGINX, acesse. Verificar se o HTTPS usa o certificado que você configurou

Configurar o servidor web HAProxy

Use esta seção para configurar o HAProxy com o provedor OpenSSL. Os exemplos a seguir mostram como configurar o HAProxy com seus certificados e chaves do CloudHSM.

Para configurar o HAProxy para o provedor OpenSSL

Faça backup do arquivo de certificado combinado existente, se ele existir:
```
$ cp server-combined.pem server-combined.pem.backup
```
Crie um arquivo de certificado combinado para o HAProxy usando seu certificado e a chave PEM falsa do CloudHSM:
```
$ cat server.crt server.key > server-combined.pem
```

Faça backup da configuração existente do HAProxy:


$ cp /etc/haproxy/haproxy.cfg /etc/haproxy/haproxy.cfg.backup

Crie uma nova configuração de descarregamento TLS do CloudHSM em: /etc/haproxy/haproxy.cfg


global
    daemon
    ssl-provider cloudhsm
    # It is *strongly* recommended to generate unique DH parameters
    # Generate them with: openssl dhparam -out /etc/haproxy/dhparams.pem 2048
    # ssl-dh-param-file /etc/haproxy/dhparams.pem
    ssl-default-bind-ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305
    ssl-default-bind-ciphersuites TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256
    ssl-default-bind-options ssl-min-ver TLSv1.2 no-tls-tickets

defaults
    mode http
    timeout connect 5000ms
    timeout client 50000ms
    timeout server 50000ms

frontend haproxy_frontend
    bind *:443 ssl crt /path/to/server-combined.pem
    default_backend web_servers

backend web_servers
    server web1 127.0.0.1:8080 check

Atualize o caminho do certificado para que corresponda ao local do seu arquivo.

Configure o systemd para usar um arquivo de ambiente para o HAProxy. A localização depende da sua distribuição Linux.
Amazon Linux and RHEL
Faça backup e modifique o arquivo de serviço HAProxy:
```
$ cp /lib/systemd/system/haproxy.service /lib/systemd/system/haproxy.service.backup
```
Edite /lib/systemd/system/haproxy.service e adicione a seguinte linha na seção [Serviço]:
```
EnvironmentFile=/etc/sysconfig/haproxy
```
Ubuntu
Faça backup e modifique o arquivo de serviço HAProxy:
```
$ cp /lib/systemd/system/haproxy.service /lib/systemd/system/haproxy.service.backup
```
Edite /lib/systemd/system/haproxy.service e adicione a seguinte linha na seção [Serviço]:
```
EnvironmentFile=/etc/default/haproxy
```
Crie o arquivo de ambiente no local apropriado para seu sistema.
Amazon Linux and RHEL
Faça backup do arquivo de ambiente HAProxy, se ele existir:
```
$ cp /etc/sysconfig/haproxy /etc/sysconfig/haproxy.backup
```
Crie o arquivo de ambiente HAProxy /etc/sysconfig/haproxy com o seguinte conteúdo:
```
CLOUDHSM_PIN=<CU user name>:<password>
```
Ubuntu
Faça backup do arquivo de ambiente HAProxy, se ele existir:
```
$ cp /etc/default/haproxy /etc/default/haproxy.backup
```
Crie o arquivo de ambiente HAProxy /etc/default/haproxy com o seguinte conteúdo:
```
CLOUDHSM_PIN=<CU user name>:<password>
```
Substitua <CU user name> e <password> por suas credenciais de UC.
Recarregue a configuração do systemd:
```
$ systemctl daemon-reload
```
Inicie o HAProxy com a configuração de descarga TLS do CloudHSM:
```
$ systemctl start haproxy
```
Você também pode executar o HAProxy diretamente com um arquivo de configuração personalizado:
```
$ haproxy -f /path/to/haproxy-cloudhsm.cfg
```

Depois de configurar o HAProxy, vá paraVerificar se o HTTPS usa o certificado que você configurou.

Etapa 4: permitir tráfego HTTPS e verificar o certificado

Depois de configurar seu servidor web para ser SSL/TLS descarregado com AWS CloudHSM, adicione sua instância de servidor web a um grupo de segurança que permita tráfego HTTPS de entrada. Isso permite que clientes, como navegadores da Web, estabeleçam uma conexão HTTPS com seu servidor Web. Em seguida, faça uma conexão HTTPS com seu servidor web e verifique se ele está usando o certificado que você configurou para SSL/TLS descarregar. AWS CloudHSM

Tópicos

Habilitar conexões HTTPS de entrada
Verificar se o HTTPS usa o certificado que você configurou

Habilitar conexões HTTPS de entrada

Para se conectar ao seu servidor Web a partir de um cliente (como um navegador da Web), crie um grupo de segurança que permita conexões HTTPS de entrada. Especificamente, ele deve permitir conexões TCP de entrada na porta 443. Atribua esse grupo de segurança ao seu servidor Web.

Para criar um grupo de segurança para HTTPS e atribuí-lo ao seu servidor Web

Abra o console do Amazon EC2 em https://console.aws.amazon.com/ec2/.
No painel de navegação, escolha Grupos de segurança.
Escolha Create security group (Criar grupo de segurança).
Para Create Security Group, faça o seguinte:
1. Para Security group name, digite um nome para security group que você está criando.
2. (Opcional) Digite uma descrição do security group que você está criando.
3. Para VPC, escolha a VPC que contém a instância do Amazon EC2 do servidor Web.
4. Selecione Adicionar regra.
5. Em Tipo, selecione HTTPS na janela suspensa.
6. Em Fonte, insira um local de origem.
7. Escolha Create security group (Criar grupo de segurança).
No painel de navegação, escolha Instâncias.
Marque a caixa de seleção ao lado da sua instância do servidor Web.
Selecione o menu suspenso Ações, na parte superior da página. Selecione Segurança e, em seguida, Alterar grupos de segurança.
Em Grupos de segurança associados, escolha a caixa de pesquisa e escolha o grupo de segurança que você criou para HTTPS. Em seguida, escolha Adicionar grupos de segurança.
Selecione Save (Salvar).

Verificar se o HTTPS usa o certificado que você configurou

Depois de adicionar o servidor web a um grupo de segurança, você pode verificar se o SSL/TLS descarregamento está usando seu certificado autoassinado. Faça isso com um navegador da Web ou com uma ferramenta como OpenSSL s_client.

Para verificar o SSL/TLS descarregamento com um navegador da web

Use um navegador da Web para se conectar ao servidor Web usando o nome de DNS público ou endereço IP do servidor. Certifique-se de que o URL na barra de endereço comece com https://. Por exemplo,https://ec2-52-14-212-67.us-east-2.compute.amazonaws.com/.

dica
Você pode usar um serviço de DNS, como o Amazon Route 53, para rotear o nome de domínio do seu site (por exemplo,https://www.example.com/) para o seu servidor web. Para obter mais informações, consulte Roteamento de tráfego para uma instância do Amazon EC2 no Amazon Route 53 ou na documentação do seu serviço de DNS.
Use seu navegador da Web para ver o certificado do servidor Web. Para obter mais informações, consulte:
- Para o Mozilla Firefox, consulte o tópico sobre como Visualizar um certificado, no site de suporte da Mozilla.
- Para o Google Chrome, consulte Noções básicas de problemas de segurança, no site Google Tools for Web Developers.
Outros navegadores da Web podem ter recursos semelhantes, que você pode usar para visualizar o certificado do servidor Web.
Certifique-se de que o SSL/TLS certificado seja aquele que você configurou seu servidor web para usar.

Para verificar o SSL/TLS descarregamento com o OpenSSL s_client

Execute o seguinte comando OpenSSL para se conectar ao seu servidor Web usando HTTPS. <server name>Substitua pelo nome DNS público ou endereço IP do seu servidor web.
```
openssl s_client -connect <server name>:443
```
dica
Você pode usar um serviço de DNS, como o Amazon Route 53, para rotear o nome de domínio do seu site (por exemplo,https://www.example.com/) para o seu servidor web. Para obter mais informações, consulte Roteamento de tráfego para uma instância do Amazon EC2 no Amazon Route 53 ou na documentação do seu serviço de DNS.
Certifique-se de que o SSL/TLS certificado seja aquele que você configurou seu servidor web para usar.

Agora você tem um site protegido com HTTPS. A chave privada do servidor web é armazenada em um HSM em seu AWS CloudHSM cluster.

Para adicionar um balanceador de carga, consulte Adicione um balanceador de carga com o Elastic Load Balancing AWS CloudHSM para (opcional).

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Descarregue no Linux com o OpenSSL Engine

Descarregamento no Linux com JSSE

AWS CloudHSM SSL/TLS descarregar no Linux usando NGINX ou HAProxy com OpenSSL Provider

Tópicos

Visão geral do

Etapa 1: configurar os pré-requisitos

Pré-requisitos para AWS CloudHSM Provedor OpenSSL

nota

Para configurar uma instância do servidor web do Linux e criar um CU no HSM

nota

dica

Observações

Etapa 2: gerar ou importar uma chave privada e obter um certificado

Gerar uma chave privada

Instalar e configurar a CloudHSM CLI

Ed25519: disponibilidade

ML-DSA disponibilidade e requisitos

Para chaves RSA e EC

Para Ed25519 e chaves ML-DSA

Gere um certificado autoassinado

Atenção

Instalar e configurar o provedor OpenSSL

Gere um certificado

ML-DSA Requisito de versão do OpenSSL

Algoritmo de resumo necessário para chaves RSA e EC

Etapa 3: configure o servidor Web

Tópicos

Configurar o servidor da Web NGINX

Para configurar o NGINX para o provedor OpenSSL

nota

nota

Configurar o servidor web HAProxy

Para configurar o HAProxy para o provedor OpenSSL

Etapa 4: permitir tráfego HTTPS e verificar o certificado

Tópicos

Habilitar conexões HTTPS de entrada

Para criar um grupo de segurança para HTTPS e atribuí-lo ao seu servidor Web

Verificar se o HTTPS usa o certificado que você configurou

Para verificar o SSL/TLS descarregamento com um navegador da web

dica

Para verificar o SSL/TLS descarregamento com o OpenSSL s_client

dica