Esta página foi traduzida pela API Cloud Translation.

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 globais
- Balanceador de carga de aplicações externo global
- Balanceador de carga de aplicações clássico
- Balanceador de carga de rede de proxy externo (com um proxy SSL de destino)

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. Google Cloud

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. Google Cloud 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. Google Cloud 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:

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

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.

OGoogle Cloud 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. Google Cloud 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.

Consola

Pode criar certificados SSL globais a partir do separador Certificados clássicos na consola do Google Cloud .

Não é possível criar certificados SSL regionais a partir do separador Certificados clássicos na Google Cloud consola. Use gcloud ou a API REST. Também é possível criar certificados SSL regionais como parte do fluxo de trabalho de criação do Application Load Balancer regional através da Google Cloud consola.

Aceda ao separador Certificado clássico na Google Cloud consola.
Aceder aos certificados clássicos
Clique em Criar certificado SSL.
Introduza um nome e uma descrição opcional para o certificado.
Selecione Carregar o meu certificado.
Cole o certificado ou clique em Carregar para navegar até ao ficheiro do certificado.
Pode optar por incluir a cadeia de certificados da AC no mesmo ficheiro que o certificado. O Google Ads não valida a cadeia de certificados por si. A validação é da sua responsabilidade. Google Cloud
Cole a chave privada ou clique em Carregar para navegar até ao ficheiro de chave privada.
Clique em Criar.

gcloud

Para criar um certificado SSL global, use o comando gcloud compute ssl-certificates create com a flag --global:

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

Para criar um certificado SSL regional, use o comando gcloud compute ssl-certificates create com a flag --region:

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

Substitua o seguinte:

CERTIFICATE_NAME: o nome do recurso de certificado a criar
CERTIFICATE_FILE: o caminho para um ficheiro de certificado formatado em PEM

Pode optar por incluir a cadeia de certificados da AC no mesmo ficheiro que o certificado. Google Cloud não valida a cadeia de certificados por si. A validação é da sua responsabilidade.
PRIVATE_KEY_FILE: o caminho para uma chave privada formatada em PEM; a chave privada não pode ser protegida por uma frase de acesso
REGION: se aplicável, a região do certificado SSL regional

Se este recurso de certificado for para um balanceador de carga de aplicações interno ou um balanceador de carga de aplicações externo regional, a região tem de ser a mesma que a região do balanceador de carga.

Java

Para usar os métodos da API, primeiro tem de ler os ficheiros de certificado e de chave privada e, em seguida, criar o certificado SSL. Isto acontece porque o pedido de API tem de incluir o conteúdo dos ficheiros.

O exemplo seguinte mostra como o fazer com Java.

Para certificados SSL globais, use o método da API sslCertificates.insert:


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

public class CreateCertificate {

  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";

    createCertificate(project, certificate, privateKey, certificateName);
  }

  // Create a global SSL self-signed certificate within your Google Cloud project.
  public static SslCertificate createCertificate(String project, String certificate,
                                                 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 (SslCertificatesClient client = SslCertificatesClient.create()) {
      SslCertificate certificateResource = SslCertificate.newBuilder()
              .setCertificate(certificate)
              .setPrivateKey(privateKey)
              .setName(certificateName)
              .build();

      InsertSslCertificateRequest request = InsertSslCertificateRequest.newBuilder()
              .setProject(project)
              .setSslCertificateResource(certificateResource)
              .build();

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

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

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

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

      return sslCert;
    }
  }
}

Para certificados SSL regionais, use o método da API regionSslCertificates.insert:


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;
    }
  }
}

Para ver exemplos de código adicionais, consulte a página de referência da API.

Python

Os exemplos seguintes mostram como o fazer com Python.

Para certificados SSL globais, use o método da API sslCertificates.insert:

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

from googleapiclient import discovery


def create_certificate(
    project_id: 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 global 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.
        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 global 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.sslCertificates().insert(
        project=project_id, body=ssl_certificate_body
    )
    response = request.execute()
    pprint(response)
    return response

Para certificados SSL regionais, use o método da API regionSslCertificates.insert:

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

Para ver exemplos de código adicionais, consulte a página de referência da API.

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.

Consola

Quando usa a consola para editar um equilibrador de carga existente, associa automaticamente o certificado SSL ao proxy de destino adequado. Google Cloud

gcloud

Para associar um certificado SSL global a um proxy HTTPS de destino, use o comando gcloud compute target-https-proxies update com as flags --global e --global-ssl-certificates:

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

Para associar um certificado SSL global a um proxy SSL de destino, use o comando gcloud compute target-ssl-proxies update:

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

Para associar um certificado SSL regional a um proxy HTTPS de destino, use o comando gcloud compute target-https-proxies update com as flags --region e --ssl-certificates-region:

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

Substitua o seguinte:

TARGET_PROXY_NAME: o nome do proxy de destino do balanceador de carga
REGION (se aplicável): a região para o proxy de destino regional e o certificado SSL regional; as regiões têm de corresponder
SSL_CERTIFICATE_LIST: uma lista delimitada por vírgulas de Google Cloud nomes de certificados SSL

Certifique-se de que a lista de certificados referenciados inclui todos os certificados SSL válidos mais antigos, bem como o novo certificado SSL. O comando gcloud compute target-ssl-proxies update substitui os valores originais de --ssl-certificates pelo novo valor.

API

Para associar um certificado SSL global a um proxy HTTPS de destino, faça um pedido POST ao método targetHttpsProxies.insert, substituindo PROJECT_ID pelo ID do seu projeto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/targetHttpsProxy

{
"name": "l7-xlb-proxy",
"urlMap": "projects/PROJECT_ID/global/urlMaps/l7-xlb-map",
"sslCertificates": /projectsPROJECT_IDglobal/sslCertificates/SSL_CERT_NAME
}

Para associar um certificado SSL global a um proxy HTTPS de destino, faça um pedido POST ao método targetSslProxies.insert, substituindo PROJECT_ID pelo ID do seu projeto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/targetSslProxy

{
"name": "l7-ssl-proxy",
"sslCertificates": /projectsPROJECT_IDglobal/sslCertificates/SSL_CERT_NAME
}

Para associar um certificado SSL regional a um proxy HTTPS de destino, faça um pedido POST ao método targetHttpsProxies.insert, substituindo PROJECT_ID pelo ID do seu projeto.

POST https://compute.googleapis.com/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

Consola

Pode verificar o estado dos seus certificados SSL globais no separador Certificados clássicos na página Gestor de certificados. Não é possível manter os certificados SSL regionais na consola Google Cloud . Use gcloud ou a API REST.

Aceda ao separador Certificados clássicos na Google Cloud consola.
Aceder aos certificados clássicos
(Opcional) Filtre a lista de certificados SSL.

gcloud

Para apresentar uma lista de certificados SSL globais, use o comando gcloud compute ssl-certificates list com o sinalizador --global:

gcloud compute ssl-certificates list \
   --global

Para listar certificados SSL regionais, use o comando gcloud compute ssl-certificates list com o filtro region:

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

Substitua o seguinte:

REGION: a Google Cloud region; include multiple regions as a space-separated list

Descreva os certificados SSL

Consola

Pode ver detalhes adicionais acerca dos seus certificados SSL globais no separador Certificados clássicos na página Gestor de certificados.

Aceda à página Certificados clássicos na Google Cloud consola.
Aceder aos certificados clássicos
(Opcional) Filtre a lista de certificados SSL.
Para ver mais detalhes, clique no nome do certificado.

gcloud

Para descrever um certificado SSL global, use o comando gcloud compute ssl-certificates describe com a flag --global:

gcloud  compute ssl-certificates describe CERTIFICATE_NAME \
   --global

Para descrever um certificado SSL regional, use o comando gcloud compute ssl-certificates describe com a flag --region:

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

Substitua o seguinte:

CERTIFICATE_NAME: o nome do certificado SSL
REGION: a Google Cloud 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.

Consola

Pode eliminar certificados SSL globais no separador Certificados clássicos na página Gestor de certificados.

Aceda ao separador Certificados clássicos na Google Cloud consola.
Aceder aos certificados clássicos
Selecione o certificado SSL que quer eliminar.
Clique em Eliminar.
Para confirmar, clique novamente em Eliminar.

gcloud

Para eliminar um certificado SSL global, use o comando gcloud compute ssl-certificates delete com o comando --global:

gcloud compute ssl-certificates delete CERTIFICATE_NAME \
    --global

Para eliminar um certificado SSL regional, use o comando gcloud compute ssl-certificates delete com o comando --region:

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

Substitua o seguinte:

CERTIFICATE_NAME: o nome do certificado SSL
REGION: a Google Cloud region

Substitua ou renove um certificado SSL antes que expire

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

Execute o comando gcloud compute ssl-certificates describe para o certificado atual, para verificar se está prestes a expirar.
Crie um novo recurso de certificado SSL. O novo certificado SSL tem de ter um nome exclusivo no projeto.
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 globais:

Use o comando gcloud compute target-https-proxies update com a flag --global.
```
gcloud compute target-https-proxies update TARGET_PROXY_NAME \
   --global \
   --ssl-certificates=new-ssl-cert,other-certificates \
   --global-ssl-certificates
```
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
```
Para equilibradores de carga de rede de proxy externos:

Use o comando gcloud compute target-ssl-proxies update com a flag --backend-service.
```
gcloud compute target-ssl-proxies update TARGET_PROXY_NAME \
   --ssl-certificates=new-ssl-cert,other-certificates
```
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
```
Nota: se vários certificados corresponderem ao nome do anfitrião SNI especificado pelo cliente, o balanceador de carga pode selecionar um certificado diferente do certificado principal (o primeiro certificado na lista). Para obter detalhes, consulte o artigo Vários certificados SSL.
Aguarde 15 minutos para garantir que a operação de substituição foi propagada a todos os front-ends da Google (GFEs).
(Opcional) Elimine o certificado SSL antigo.

Rode os certificados SSL periodicamente

Esta solução de exemplo verifica periodicamente o estado dos certificados usados com os balanceadores de carga Google Cloud e roda os certificados quando atingem uma determinada percentagem da respetiva duração. A ferramenta usa ACs configuradas através do Certificate Authority Service.

Esta solução funciona com os seguintes equilibradores de carga:

Balanceador de carga de aplicações externo global
Balanceador de carga de aplicações clássico
Balanceador de carga de aplicações externo regional
Balanceador de carga de aplicações interno
Balanceador de carga de rede de proxy externo com um proxy SSL

O que se segue?

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

Use certificados SSL autogeridos Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Antes de começar

Autorizações

Passo 1: crie uma chave privada e um certificado

Selecione ou crie uma chave privada

Crie um pedido de assinatura de certificado (CSR)

Assine o CSR

Use uma AC fidedigna publicamente

Use a sua própria AC interna

Use um certificado autoassinado

Carateres universais em nomes comuns

Passo 2: crie um recurso de certificado SSL autogerido

Consola

gcloud

Java

Python

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

Consola

gcloud

API

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

Passo 5: teste com o OpenSSL

Trabalhe com certificados SSL autogeridos

Liste certificados SSL

Consola

gcloud

Descreva os certificados SSL

Consola

gcloud

Elimine certificados SSL

Consola

gcloud

Substitua ou renove um certificado SSL antes que expire

Rode os certificados SSL periodicamente

O que se segue?

Use certificados SSL autogeridos