Use certificados SSL autogeridos

Os certificados SSL autogeridos são certificados que obtém, aprovisiona e renova por si. Pode usar este recurso para proteger a comunicação entre os clientes e o seu equilibrador de carga.

Os certificados autogeridos podem ser qualquer combinação dos seguintes tipos de certificados:

• Validação de domínio (DV)
• Validação da organização (OV)
• Validação alargada (EV)

Os certificados autogeridos são suportados com os seguintes equilibradores de carga:

• Certificados regionais
  • Balanceador de carga de aplicações externo regional
  • Balanceador de carga de aplicações interno regional

Esta página descreve o processo de obtenção de um certificado do Compute Engine válido e, em seguida, o carregamento do certificado para criar um recurso de certificado SSL. Cloud de Confiance

Para criar certificados geridos pela Google através do Gestor de certificados, consulte a Vista geral da implementação.

Antes de começar

• Certifique-se de que conhece a vista geral dos certificados SSL.
• Certifique-se de que tem os nomes de domínio que quer usar para o seu certificado SSL autogerido. Se estiver a usar o Cloud Domains, consulte o Passo 1: registe um nome de domínio através do Cloud Domains.

Autorizações

Para realizar as tarefas neste guia, tem de conseguir criar e modificar certificados SSL no seu projeto. Pode fazê-lo se uma das seguintes afirmações for verdadeira:

• É proprietário ou editor (roles/owner ou roles/editor) de um projeto.
• Tem a função de administrador de segurança de computação (compute.securityAdmin) e a função de administrador de rede de computação (compute.networkAdmin) no projeto.
• Tem uma função personalizada para o projeto que inclui as autorizações compute.sslCertificates.* e uma ou ambas as autorizações compute.targetHttpsProxies.* e compute.targetSslProxies.*, consoante o tipo de equilibrador de carga que está a usar.

Passo 1: crie uma chave privada e um certificado

Se já tiver uma chave privada e um certificado de uma autoridade de certificação (AC), ignore esta secção e aceda a Criar um recurso de certificado SSL.

Selecione ou crie uma chave privada

Um certificado SSL inclui uma chave privada e o próprio certificado, ambos no formato PEM. Cloud de Confiance A sua chave privada tem de cumprir os seguintes critérios:

• Tem de estar no formato PEM.
• Não pode ser protegida por uma frase secreta. Cloud de Confiance Armazena a sua chave privada no seu próprio formato encriptado.
• O respetivo algoritmo de encriptação tem de ser RSA ou ECDSA. Para saber que tipos de chaves pode usar, consulte a secção Tipos de chaves suportados.

Para criar uma nova chave privada, use um dos seguintes comandos OpenSSL.

• Crie uma chave privada RSA-2048:

  openssl genrsa -out PRIVATE_KEY_FILE 2048
  

• Crie uma chave privada ECDSA P-256:

  openssl ecparam -name prime256v1 -genkey -noout -out PRIVATE_KEY_FILE
  

Substitua PRIVATE_KEY_FILE pelo caminho e nome do ficheiro da nova chave privada.

Crie um pedido de assinatura de certificado (CSR)

Depois de ter uma chave privada, pode gerar um pedido de assinatura de certificado (CSR) no formato PEM através do OpenSSL. O CSR tem de cumprir os seguintes critérios:

• Tem de estar no formato PEM.
• Tem de ter um nome comum (CN) ou um atributo de nome alternativo do requerente (SAN). Na prática, o seu certificado deve conter os atributos both CN e SAN, mesmo que seja para um único domínio. Os clientes modernos, como as versões atuais do macOS e do iOS, não dependem apenas do atributo CN.

Para criar um CSR, siga estes passos:

1. Crie um ficheiro de configuração do OpenSSL. No exemplo seguinte, os nomes alternativos do requerente estão definidos no [sans_list].

   cat <<'EOF' >CONFIG_FILE
   [req]
   default_bits              = 2048
   req_extensions            = extension_requirements
   distinguished_name        = dn_requirements
   prompt                    = no
   
   [extension_requirements]
   basicConstraints          = CA:FALSE
   keyUsage                  = nonRepudiation, digitalSignature, keyEncipherment
   subjectAltName            = @sans_list
   
   [dn_requirements]
   countryName               = Country Name (2 letter code)
   stateOrProvinceName       = State or Province Name (full name)
   localityName              = Locality Name (eg, city)
   0.organizationName        = Organization Name (eg, company)
   organizationalUnitName    = Organizational Unit Name (eg, section)
   commonName                = Common Name (e.g. server FQDN or YOUR name)
   emailAddress              = Email Address
   
   [sans_list]
   DNS.1                     = SUBJECT_ALTERNATIVE_NAME_1
   DNS.2                     = SUBJECT_ALTERNATIVE_NAME_2
   
   EOF
   

2. Execute o seguinte comando OpenSSL para criar um ficheiro de pedido de assinatura de certificado (CSR). O comando é interativo. São-lhe pedidos atributos, exceto os nomes alternativos do requerente, que definiu no [sans_list] do CONFIG_FILE no passo anterior.

   openssl req -new -key PRIVATE_KEY_FILE \
       -out CSR_FILE \
       -config CONFIG_FILE
   

Para ambos os passos, substitua o seguinte:

• CONFIG_FILE: o caminho, incluindo o nome do ficheiro, para o ficheiro de configuração do OpenSSL (pode eliminar o ficheiro depois de concluir este procedimento)

• SUBJECT_ALTERNATIVE_NAME_1 e SUBJECT_ALTERNATIVE_NAME_2: nomes alternativos do requerente para o seu certificado

  Se o seu certificado for apenas para um nome de anfitrião, deve definir apenas um nome alternativo de entidade que corresponda ao nome comum. Se precisar de mais de dois nomes alternativos do assunto, adicione-os ao ficheiro de configuração, incrementando o número após DNS (DNS.3, DNS.4, etc.).

• PRIVATE_KEY_FILE: o caminho para o ficheiro de chave privada

• CSR_FILE: o caminho, incluindo o nome do ficheiro, para o CSR

Assine o CSR

Quando uma autoridade de certificação (CA) assina o seu CSR, usa a sua própria chave privada para criar um certificado. Use um dos seguintes métodos para assinar o CSR:

Use uma AC fidedigna publicamente

Se pedir a uma AC publicamente fidedigna que assine o seu CSR, o certificado resultante é fidedigno para todos os clientes que confiam nessa AC pública. Para produzir um certificado assinado, a CA pública só precisa do seu CSR.

Use a sua própria AC interna

Se gerir a sua própria AC, pode usá-la para assinar o seu CSR. A utilização da sua AC para assinar a CSR cria um certificado fidedigno internamente quando os seus clientes também foram configurados para confiar na sua própria AC.

Use um certificado autoassinado

Se usar a mesma chave privada que usou para criar o CSR para assinar o CSR, criou um certificado autoassinado. Só deve usar certificados autoassinados para testes.

OCloud de Confiance não suporta a validação do lado do cliente para certificados de servidor autossinados. Por conseguinte, tem de configurar o cliente para ignorar a validação de certificados. Por exemplo, pode criar um cliente de navegador de Internet que apresente uma mensagem a perguntar se quer confiar num certificado autoassinado.

Se gerir a sua própria AC ou quiser criar um certificado autoassinado para testes, pode usar o seguinte comando OpenSSL:

openssl x509 -req \
    -signkey PRIVATE_KEY_FILE \
    -in CSR_FILE \
    -out CERTIFICATE_FILE \
    -extfile CONFIG_FILE \
    -extensions extension_requirements \
    -days TERM

Substitua o seguinte:

• PRIVATE_KEY_FILE: o caminho para a chave privada da sua AC; se estiver a criar um certificado autoassinado para testes, esta chave privada é igual à usada para criar o CSR
• CSR_FILE: o caminho para o CSR
• CERTIFICATE_FILE: o caminho para o ficheiro de certificado a criar
• TERM: o número de dias, a partir de agora, durante os quais o certificado deve ser considerado válido pelos clientes que o validam

Carateres universais em nomes comuns

Os seus certificados SSL autogeridos podem usar um caráter universal no nome comum. Por exemplo, um certificado com o nome comum *.example.com. corresponde aos nomes de anfitrião www.example.com e foo.example.com, mas não a a.b.example.com nem a example.com. Quando o equilibrador de carga seleciona um certificado, prefere sempre fazer corresponder um nome de anfitrião a certificados sem carateres universais em vez de certificados com carateres universais.

Os certificados com fragmentos de carateres universais, como f*.example.com, não são compatíveis.

Passo 2: crie um recurso de certificado SSL autogerido

Antes de poder criar um recurso de certificado SSL, tem de ter uma chave privada e um certificado. Cloud de Confiance Consulte o artigo Criar uma chave privada e um certificado se ainda não os tiver criado ou obtido.

Depois de criar um certificado, não pode alterar o respetivo âmbito de global para regional, nem de regional para global.

gcloud compute ssl-certificates create CERTIFICATE_NAME \
    --certificate=CERTIFICATE_FILE \
    --private-key=PRIVATE_KEY_FILE \
    --region=REGION

import com.google.cloud.compute.v1.InsertRegionSslCertificateRequest;
import com.google.cloud.compute.v1.RegionSslCertificatesClient;
import com.google.cloud.compute.v1.SslCertificate;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateRegionalCertificate {
  public static void main(String[] args)
          throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String project = "your-project-id";
    // The certificate you want to create in your project.
    String certificate = "your-certificate";
    // The private key you used to sign the certificate with.
    String privateKey = "your-private-key";
    // Name for the certificate once it's created in your project.
    String certificateName = "your-certificate-name";
    // Name of the region you want to use.
    String region = "your-region";

    createRegionCertificate(project, certificate, region, privateKey, certificateName);
  }

  // Create a regional SSL self-signed certificate within your Google Cloud project.
  public static SslCertificate createRegionCertificate(String project, String certificate,
                                                       String region, String privateKey,
                                                       String certificateName)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (RegionSslCertificatesClient client = RegionSslCertificatesClient.create()) {
      SslCertificate certificateResource = SslCertificate.newBuilder()
              .setCertificate(certificate)
              .setPrivateKey(privateKey)
              .setName(certificateName)
              .build();

      InsertRegionSslCertificateRequest request = InsertRegionSslCertificateRequest.newBuilder()
              .setProject(project)
              .setRegion(region)
              .setSslCertificateResource(certificateResource)
              .build();

      client.insertCallable().futureCall(request).get(60, TimeUnit.SECONDS);

      // Wait for server update
      TimeUnit.SECONDS.sleep(1);

      SslCertificate sslCert = client.get(project, region, certificateName);

      System.out.printf("Regional cert '%s' has been created successfully", sslCert.getName());

      return sslCert;
    }
  }
}

from pathlib import Path
from pprint import pprint
from typing import Union

from googleapiclient import discovery


def create_regional_certificate(
    project_id: str,
    region: str,
    certificate_file: Union[str, Path],
    private_key_file: Union[str, Path],
    certificate_name: str,
    description: str = "Certificate created from a code sample.",
) -> dict:
    """
    Create a regional SSL self-signed certificate within your Google Cloud project.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use.
        certificate_file: path to the file with the certificate you want to create in your project.
        private_key_file: path to the private key you used to sign the certificate with.
        certificate_name: name for the certificate once it's created in your project.
        description: description of the certificate.

        Returns:
        Dictionary with information about the new regional SSL self-signed certificate.
    """
    service = discovery.build("compute", "v1")

    # Read the cert into memory
    with open(certificate_file) as f:
        _temp_cert = f.read()

    # Read the private_key into memory
    with open(private_key_file) as f:
        _temp_key = f.read()

    # Now that the certificate and private key are in memory, you can create the
    # certificate resource
    ssl_certificate_body = {
        "name": certificate_name,
        "description": description,
        "certificate": _temp_cert,
        "privateKey": _temp_key,
    }
    request = service.regionSslCertificates().insert(
        project=project_id, region=region, body=ssl_certificate_body
    )
    response = request.execute()
    pprint(response)

    return response

Passo 3: associe um certificado SSL a um proxy de destino

Tem de associar, pelo menos, um certificado SSL a cada proxy HTTPS ou SSL de destino. Pode configurar o proxy de destino com até o número máximo de certificados SSL por proxy HTTPS ou SSL de destino. Pode fazer referência a vários certificados autogeridos no mesmo proxy de destino.

gcloud compute target-https-proxies update TARGET_PROXY_NAME \
    --region=REGION \
    --ssl-certificates=SSL_CERTIFICATE_LIST \
    --ssl-certificates-region=REGION

POST https://compute.s3nsapis.fr/compute/v1/projects/PROJECT_ID/global/targetHttpsProxy

{
"name": "l7-xlb-proxy",
"urlMap": "projects/PROJECT_ID/global/urlMaps/l7-ilb-map",
"region": "us-west1"
"sslCertificates": /projectsPROJECT_IDregions/us-west1/sslCertificates/SSL_CERT_NAME
}

Passo 4: atualize os registos A e AAAA de DNS para apontarem para o endereço IP do balanceador de carga

No site do registador, no anfitrião de DNS ou no ISP (onde quer que os registos de DNS sejam geridos), adicione ou atualize os registos A de DNS (para IPv4) e os registos AAAA de DNS (para IPv6) dos seus domínios e subdomínios para que apontem para o endereço IP associado à regra ou às regras de encaminhamento do balanceador de carga.

Se estiver a usar o Cloud DNS e o Cloud Domains, configure os seus domínios e atualize os servidores de nomes.

Se estiver a usar vários domínios para um único certificado, tem de adicionar ou atualizar os registos de DNS para todos os domínios e subdomínios, de modo que todos apontem para o endereço IP do seu equilibrador de carga.

Depois de aguardar a propagação do DNS para concluir, pode validar a configuração executando o comando dig. Por exemplo, suponhamos que o seu domínio é www.example.com. Execute o seguinte comando dig:

dig www.example.com

; <<>> DiG 9.10.6 <<>> www.example.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 31748
;; flags: qr rd ra; QUERY: 1, ANSWER: 4, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 512
;; QUESTION SECTION:
;www.example.com.           IN  A

;; ANSWER SECTION:
www.example.com.        1742    IN  CNAME   www.example.com.edgekey.net.
www.example.com.edgekey.net. 21330 IN   CNAME   www.example.com.edgekey.net.globalredir.akadns.net.
www.example.com.edgekey.net.globalredir.akadns.net. 3356 IN CNAME   e6858.dsce9.akamaiedge.net.
e6858.dsce9.akamaiedge.net. 19  IN  A   203.0.113.5

;; Query time: 43 msec
;; SERVER: 8.8.8.8#53(8.8.8.8)
;; WHEN: Wed Jun 03 16:54:44 PDT 2020
;; MSG SIZE  rcvd: 193

Neste exemplo, 203.0.113.5 é o endereço IP do seu equilibrador de carga.

Passo 5: teste com o OpenSSL

O seu equilibrador de carga pode demorar até 30 minutos a começar a usar o certificado SSL autogerido.

Para testar, execute o seguinte comando OpenSSL, substituindo DOMAIN pelo nome DNS e IP_ADDRESS pelo endereço IP do equilibrador de carga.

echo | openssl s_client -showcerts -servername DOMAIN -connect IP_ADDRESS:443 -verify 99 -verify_return_error

Este comando produz os certificados que o equilibrador de carga apresenta ao cliente. Juntamente com outras informações detalhadas, o resultado deve incluir a cadeia de certificados e Verify return code: 0 (ok).

Trabalhe com certificados SSL autogeridos

As secções seguintes descrevem como listar, ver, eliminar e substituir recursos de certificados SSL.

Liste certificados SSL

gcloud compute ssl-certificates list \
   --filter="region:(REGION ...)"

Descreva os certificados SSL

gcloud compute ssl-certificates describe CERTIFICATE_NAME \
   --region=REGION

Elimine certificados SSL

Antes de poder eliminar um certificado SSL, tem de atualizar primeiro cada proxy de destino que faça referência ao certificado. Para cada proxy de destino, execute o comando gcloud update adequado para atualizar o SSL_CERTIFICATE_LIST do proxy de destino de modo que já não inclua o certificado SSL que tem de eliminar. Cada proxy SSL de destino ou proxy HTTPS de destino tem de fazer referência a, pelo menos, um certificado SSL.

Depois de atualizar o proxy de destino, pode eliminar o certificado SSL.

gcloud compute ssl-certificates delete CERTIFICATE_NAME \
    --region=REGION

Substitua ou renove um certificado SSL antes que expire

Siga estes passos se precisar de substituir, renovar ou rodar um certificado SSL:

1. Execute o comando gcloud compute ssl-certificates describe para o certificado atual, para verificar se está prestes a expirar.

2. Crie um novo recurso de certificado SSL. O novo certificado SSL tem de ter um nome exclusivo no projeto.

3. Atualize o proxy de destino para desanexar o certificado SSL antigo e adicionar o novo. Certifique-se de que inclui todos os outros certificados SSL existentes que quer manter.

   Para ajudar a evitar o tempo de inatividade, execute um único comando gcloud com a flag --ssl-certificates. Por exemplo:

   Para balanceadores de carga de aplicações externos regionais e balanceadores de carga de aplicações internos regionais:

   Use o comando gcloud compute target-https-proxies update com a flag --region.

   gcloud compute target-https-proxies update TARGET_PROXY_NAME \
      --region=REGION \
      --ssl-certificates=new-ssl-cert,other-certificates \
      --ssl-certificates-region=REGION
   

4. Verifique se o balanceador de carga está a publicar o certificado de substituição executando o seguinte comando OpenSSL:

   echo | openssl s_client -showcerts -connect IP_ADDRESS:443 -verify 99 -verify_return_error
   

5. Aguarde 15 minutos para garantir que a operação de substituição foi propagada a todos os front-ends da Google (GFEs).

6. (Opcional) Elimine o certificado SSL antigo.

O que se segue?

• Para resolver problemas de certificados SSL, consulte o artigo Resolução de problemas de certificados SSL.