Usar certificados SSL autogestionados

Los certificados SSL autogestionados son certificados que obtienes, aprovisionas y renuevas tú mismo. Puedes usar este recurso para proteger la comunicación entre los clientes y tu balanceador de carga.

Los certificados autogestionados pueden ser cualquier combinación de los siguientes tipos de certificados:

• Validación de dominio (DV)
• Validación de la organización (OV)
• Validación ampliada (VA)

Los certificados autogestionados se pueden usar con los siguientes balanceadores de carga:

• Certificados globales
  • Balanceador de carga de aplicación externo global
  • Balanceador de carga de aplicación clásico
  • Balanceador de carga de red del proxy externo (con un proxy SSL de destino)

• Certificados regionales
  • Balanceador de carga de aplicación externo regional
  • Balanceador de carga de aplicación interno regional

En esta página se describe el proceso para obtener un certificado de Compute Engine válido y, a continuación, subirlo para crear un recurso de certificado SSL. Google Cloud

Para crear certificados gestionados por Google con Certificate Manager, consulta el artículo Descripción general de la implementación.

Nota:

Para obtener información sobre los certificados autogestionados de Ingress de GKE, consulta el artículo Configurar HTTPS (TLS) entre el cliente y el balanceador de carga del documento Ingress para balanceadores de carga de aplicaciones externos.

Antes de empezar

• Familiarícese con la información general sobre los certificados SSL.
• Asegúrate de que tienes los nombres de dominio que quieres usar para tu certificado SSL autogestionado. Si usas Cloud Domains, consulta el paso 1: Registra un nombre de dominio con Cloud Domains.

Permisos

Para realizar las tareas de esta guía, debes poder crear y modificar certificados SSL en tu proyecto. Puedes hacerlo si se cumple una de las siguientes condiciones:

• Eres propietario o editor (roles/owner o roles/editor) del proyecto.
• Tienes los roles Administrador de seguridad de Compute (compute.securityAdmin) y Administrador de red de Compute (compute.networkAdmin) en el proyecto.
• Tienes un rol personalizado para el proyecto que incluye los permisos compute.sslCertificates.* y uno o ambos de compute.targetHttpsProxies.* y compute.targetSslProxies.*, en función del tipo de balanceador de carga que utilices.

Paso 1: Crea una clave privada y un certificado

Si ya tienes una clave privada y un certificado de una autoridad de certificación (CA), salta esta sección y ve a Crear un recurso de certificado SSL.

Selecciona o crea una clave privada

Un certificado SSL incluye una clave privada y el propio certificado, ambos en formato PEM. Google Cloud Tu clave privada debe cumplir los siguientes criterios:

• Debe estar en formato PEM.
• No se puede proteger con una contraseña. Google Cloud almacena tu clave privada en su propio formato cifrado.
• Su algoritmo de cifrado debe ser RSA o ECDSA. Para saber qué tipos de claves puedes usar, consulta Tipos de claves admitidos.

Para crear una clave privada, usa uno de los siguientes comandos de OpenSSL.

• Crea una clave privada RSA de 2048 bits:

  openssl genrsa -out PRIVATE_KEY_FILE 2048
  

• Crea una clave privada ECDSA P-256:

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

Sustituye PRIVATE_KEY_FILE por la ruta y el nombre de archivo de la nueva clave privada.

Crear una solicitud de firma de certificado (CSR)

Una vez que tengas una clave privada, puedes generar una solicitud de firma de certificado (CSR) en formato PEM con OpenSSL. Tu CSR debe cumplir los siguientes requisitos:

• Debe estar en formato PEM.
• Debe tener un nombre común (CN) o un atributo de nombre alternativo del sujeto (SAN). En la práctica, tu certificado debe contener ambos atributos, CN y SAN, aunque sea para un solo dominio. Los clientes modernos, como las versiones actuales de macOS y iOS, no se basan solo en el atributo CN.

Para crear una CSR, sigue estos pasos:

1. Crea un archivo de configuración de OpenSSL. En el ejemplo siguiente, los nombres alternativos de la entidad se definen en [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. Ejecuta el siguiente comando de OpenSSL para crear un archivo de solicitud de firma de certificado (CSR). El comando es interactivo. Se te pedirá que introduzcas los atributos excepto los nombres alternativos de la entidad, que definiste en la [sans_list] de CONFIG_FILE en el paso anterior.

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

En ambos pasos, sustituye lo siguiente:

• CONFIG_FILE: la ruta, incluido el nombre de archivo, del archivo de configuración de OpenSSL (puedes eliminar el archivo después de completar este procedimiento).

• SUBJECT_ALTERNATIVE_NAME_1 y SUBJECT_ALTERNATIVE_NAME_2: nombres alternativos de la entidad receptora del certificado

  Si tu certificado es solo para un nombre de host, solo debes definir un nombre alternativo del sujeto que coincida con el nombre común. Si necesitas más de dos nombres alternativos de asunto, añádelos al archivo de configuración e incrementa el número después de DNS (DNS.3, DNS.4, etc.).

• PRIVATE_KEY_FILE: la ruta al archivo de clave privada

• CSR_FILE: la ruta, incluido el nombre de archivo, de la CSR

Firmar la CSR

Cuando una autoridad de certificación (CA) firma tu CSR, utiliza su propia clave privada para crear un certificado. Utiliza uno de los siguientes métodos para firmar la CSR:

Usar una AC de confianza pública

Si solicitas a una AC pública de confianza que firme tu CSR, todos los clientes que confíen en esa AC pública confiarán en el certificado resultante. Para generar un certificado firmado, la AC pública solo necesita tu CSR.

Usar tu propia CA interna

Si gestionas tu propia CA, puedes usarla para firmar tu CSR. Si usas tu AC para firmar tu CSR, se crea un certificado de confianza interna cuando tus clientes también se han configurado para confiar en tu propia AC.

Utilizar un certificado autofirmado

Si usas la misma clave privada que usaste para crear la CSR para firmar la CSR, habrás creado un certificado autofirmado. Solo debes usar certificados autofirmados para hacer pruebas.

Google Cloud no admite la verificación del lado del cliente para certificados de servidor autofirmados. Por lo tanto, debes configurar el cliente para que omita la validación de certificados. Por ejemplo, puedes crear un cliente de navegador web que muestre un mensaje en el que se te pregunte si quieres confiar en un certificado autofirmado.

Si gestionas tu propia AC o quieres crear un certificado autofirmado para hacer pruebas, puedes usar el siguiente comando de OpenSSL:

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

Haz los cambios siguientes:

• PRIVATE_KEY_FILE: la ruta a la clave privada de tu CA. Si vas a crear un certificado autofirmado para hacer pruebas, esta clave privada es la misma que la que se usa para crear la CSR.
• CSR_FILE: la ruta a la CSR
• CERTIFICATE_FILE: la ruta al archivo de certificado que se va a crear
• TERM: el número de días, a partir de ahora, durante los cuales los clientes que lo verifiquen deben considerar que el certificado es válido

Comodines en nombres comunes

Tus certificados SSL autogestionados pueden usar un comodín en el nombre común. Por ejemplo, un certificado con el nombre común *.example.com. coincide con los nombres de host www.example.com y foo.example.com, pero no con a.b.example.com ni con example.com. Cuando el balanceador de carga selecciona un certificado, siempre prefiere que un nombre de host coincida con certificados sin comodines en lugar de con certificados con comodines.

No se admiten certificados con fragmentos comodín, como f*.example.com.

Paso 2: Crea un recurso de certificado SSL autogestionado

Antes de crear un recurso de certificado SSL, debes tener una clave privada y un certificado. Google Cloud Consulta el artículo sobre cómo crear una clave privada y un certificado si aún no los has creado u obtenido.

Después de crear un certificado, no puedes cambiar su ámbito de global a regional ni de regional a global.

Consola

Puedes crear certificados SSL globales en la pestaña Certificados clásicos de la consola de Google Cloud .

Los certificados SSL regionales no se pueden crear desde la pestaña Certificados clásicos de la consola de Google Cloud . Usa gcloud o la API REST. También se pueden crear certificados SSL regionales como parte del flujo de trabajo de creación de balanceadores de carga de aplicaciones regionales mediante la Google Cloud consola.

Nota: El siguiente procedimiento te lleva directamente a la pestaña Certificados clásicos. Puedes encontrar la pestaña Certificados clásicos en la página Gestor de certificados, a la que puedes acceder desde la página de nivel superior Seguridad.

1. Ve a la pestaña Certificado clásico de la Google Cloud consola.
   Ir a Certificados clásicos
2. Haz clic en Crear certificado SSL.
3. Introduce un nombre y, si quieres, una descripción del certificado.
4. Selecciona Subir mi certificado.
5. Pega el certificado o haz clic en Subir para ir al archivo del certificado.
   Puedes incluir la cadena de certificados de la AC en el mismo archivo que el certificado. Google Cloud no valida la cadena de certificados por ti, sino que es tu responsabilidad.
6. Pega tu clave privada o haz clic en Subir para ir al archivo de tu clave privada.
7. Haz clic en Crear.

gcloud

Para crear un certificado SSL global, usa el comando gcloud compute ssl-certificates create con la marca --global:

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

Para crear un certificado SSL regional, usa el comando gcloud compute ssl-certificates create con la marca --region:

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

Haz los cambios siguientes:

• CERTIFICATE_NAME: el nombre del recurso de certificado que se va a crear.

• CERTIFICATE_FILE: la ruta a un archivo de certificado con formato PEM

  Puedes incluir la cadena de certificados de la CA en el mismo archivo que el certificado. Google Cloud no valida la cadena de certificados por ti, sino que es tu responsabilidad.

• PRIVATE_KEY_FILE: la ruta a una clave privada con formato PEM. La clave privada no puede estar protegida por una contraseña.

• REGION: si procede, la región del certificado SSL regional

  Si este recurso de certificado es para un balanceador de carga de aplicaciones interno o un balanceador de carga de aplicaciones externo regional, la región debe ser la misma que la del balanceador de carga.

Java

Para usar los métodos de la API, primero debes leer los archivos de certificado y clave privada, y, a continuación, crear el certificado SSL. Esto se debe a que la solicitud de la API debe incluir el contenido de los archivos.

En el siguiente ejemplo se muestra cómo hacerlo con Java.

Para los certificados SSL globales, usa el método de la 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 los certificados SSL regionales, usa el método de la 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 más ejemplos de código, consulta la página de referencia de la API.

Python

Para usar los métodos de la API, primero debes leer los archivos de certificado y clave privada, y, a continuación, crear el certificado SSL. Esto se debe a que la solicitud de la API debe incluir el contenido de los archivos.

En los siguientes ejemplos se muestra cómo hacerlo con Python.

Para los certificados SSL globales, usa el método de la 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 los certificados SSL regionales, usa el método de la 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 más ejemplos de código, consulta la página de referencia de la API.

Paso 3: Asociar un certificado SSL a un proxy de destino

Debes asociar al menos un certificado SSL a cada proxy HTTPS o SSL de destino. Puedes configurar el proxy de destino con un máximo de certificados SSL por proxy HTTPS o SSL de destino. Puede hacer referencia a varios certificados autogestionados en el mismo proxy de destino.

Nota: Cuando sustituyas un certificado SSL, primero crea el certificado SSL de sustitución y asócialo al proxy de destino del balanceador de carga antes de eliminar el certificado SSL antiguo.

Consola

Cuando usas la consola de Google Cloud para editar un balanceador de carga, el certificado SSL se asocia automáticamente al proxy de destino adecuado. Google Cloud

gcloud

Para asociar un certificado SSL global a un proxy HTTPS de destino, usa el comando gcloud compute target-https-proxies update con las marcas --global y --global-ssl-certificates:

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

Para asociar un certificado SSL global a un proxy SSL de destino, usa el comando gcloud compute target-ssl-proxies update:

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

Para asociar un certificado SSL regional con un proxy HTTPS de destino, usa el comando gcloud compute target-https-proxies update con las marcas --region y --ssl-certificates-region:

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

Haz los cambios siguientes:

• TARGET_PROXY_NAME: el nombre del proxy de destino del balanceador de carga
• REGION (si procede): la región del proxy de destino regional y del certificado SSL regional. Las regiones deben coincidir.

• SSL_CERTIFICATE_LIST: lista de nombres de certificados SSL separados por comasGoogle Cloud

  Asegúrate de que la lista de certificados a los que se hace referencia incluya todos los certificados SSL antiguos válidos, así como el nuevo certificado SSL. El comando gcloud compute target-ssl-proxies update sustituye los valores originales de --ssl-certificates por el nuevo valor.

API

Para asociar un certificado SSL global a un proxy HTTPS de destino, envía una solicitud POST al método targetHttpsProxies.insert y sustituye PROJECT_ID por el ID de tu proyecto.

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 asociar un certificado SSL global a un proxy HTTPS de destino, envía una solicitud POST al método targetSslProxies.insert y sustituye PROJECT_ID por el ID de tu proyecto.

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

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

Para asociar un certificado SSL regional a un proxy HTTPS de destino, envía una solicitud POST al método targetHttpsProxies.insert y sustituye PROJECT_ID por el ID de tu proyecto.

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
}

Paso 4: Actualiza los registros A y AAAA de DNS para que apunten a la dirección IP del balanceador de carga

En el sitio de tu registrador, host de DNS o proveedor de Internet (donde se gestionen tus registros DNS), añade o actualiza los registros A de DNS (para IPv4) y los registros AAAA de DNS (para IPv6) de tus dominios y subdominios para que dirijan a la dirección IP asociada a las reglas de reenvío del balanceador de carga.

Si usas Cloud DNS y Cloud Domains, configura tus dominios y actualiza tus servidores de nombres.

Si usas varios dominios para un solo certificado, debes añadir o actualizar los registros DNS de todos los dominios y subdominios para que apunten a la dirección IP de tu balanceador de carga.

Importante: Asegúrese de que el nombre de dominio se resuelva directamente en la dirección IP de su balanceador de carga de aplicaciones externo. No se puede resolver en ninguna otra dirección IP, aunque esa otra dirección IP pase, proxy o almacene en caché las respuestas de tu balanceador de carga. Por ejemplo, no puedes usar certificados autogestionados si el nombre de tu dominio se resuelve en la dirección IP externa de un proveedor de CDN de terceros.

Después de esperar a que se complete la propagación del DNS, puedes verificar la configuración ejecutando el comando dig. Por ejemplo, supongamos que tu dominio es www.example.com. Ejecuta el siguiente 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

En este ejemplo, 203.0.113.5 es la dirección IP de tu balanceador de carga.

Paso 5: Prueba con OpenSSL

El balanceador de carga puede tardar hasta 30 minutos en empezar a usar tu certificado SSL autogestionado.

Para probarlo, ejecuta el siguiente comando de OpenSSL, sustituyendo DOMAIN por tu nombre de DNS y IP_ADDRESS por la dirección IP de tu balanceador de carga.

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

Este comando muestra los certificados que el balanceador de carga presenta al cliente. Además de otra información detallada, el resultado debe incluir la cadena de certificados y Verify return code: 0 (ok).

Trabajar con certificados SSL autogestionados

En las siguientes secciones se describe cómo enumerar, ver, eliminar y sustituir recursos de certificado SSL.

Mostrar lista de certificados SSL

Consola

Puedes consultar el estado de tus certificados SSL globales en la pestaña Certificados clásicos de la página Gestor de certificados. Los certificados SSL regionales no se pueden mantener en la consola de Google Cloud . Usa gcloud o la API REST.

1. Ve a la pestaña Certificados clásicos de la Google Cloud consola.
   Ir a Certificados clásicos
2. (Opcional) Filtra la lista de certificados SSL.

gcloud

Para ver una lista de los certificados SSL globales, usa el comando gcloud compute ssl-certificates list con la marca --global:

gcloud compute ssl-certificates list \
   --global

Para enumerar los certificados SSL regionales, usa el comando gcloud compute ssl-certificates list con el filtro region:

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

Haz los cambios siguientes:

• REGION: una región. Incluye varias regiones como una lista separada por espacios. Google Cloud

Describe los certificados SSL

Consola

Puedes ver más detalles sobre tus certificados SSL globales en la pestaña Certificados clásicos de la página Gestor de certificados.

1. Ve a la página Certificados clásicos de la Google Cloud consola.
   Ir a Certificados clásicos
2. (Opcional) Filtra la lista de certificados SSL.
3. Para ver más detalles, haz clic en el nombre del certificado.

gcloud

Para describir un certificado SSL global, usa el comando gcloud compute ssl-certificates describe con la marca --global:

gcloud  compute ssl-certificates describe CERTIFICATE_NAME \
   --global

Para describir un certificado SSL regional, usa el comando gcloud compute ssl-certificates describe con la marca --region:

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

Haz los cambios siguientes:

• CERTIFICATE_NAME: el nombre del certificado SSL
• REGION: a Google Cloud region

Nota: Google Cloud nunca devuelve el contenido de una clave privada al describir un certificado. La clave privada se almacena de forma segura y no se puede recuperar mediante la consola de Google Cloud , gcloud ni la API.

Eliminar los certificados SSL

Antes de eliminar un certificado SSL, debes actualizar cada proxy de destino que haga referencia al certificado. En cada proxy de destino, ejecute el comando gcloud update adecuado para actualizar el SSL_CERTIFICATE_LIST del proxy de destino de forma que ya no incluya el certificado SSL que quiere eliminar. Cada proxy SSL o HTTPS de destino debe hacer referencia a al menos un certificado SSL.

Nota: Para saber la secuencia de eventos que debes seguir si tienes previsto sustituir un certificado SSL, consulta el artículo Sustituir o renovar un certificado SSL antes de que caduque.

Una vez que hayas actualizado el proxy de destino, podrás eliminar el certificado SSL.

Consola

Puede eliminar certificados SSL globales en la pestaña Certificados clásicos de la página Gestor de certificados.

1. Ve a la pestaña Certificados clásicos de la Google Cloud consola.
   Ir a Certificados clásicos
2. Seleccione el certificado SSL que quiera eliminar.
3. Haz clic en Eliminar.
4. Para confirmar la acción, haz clic de nuevo en Eliminar.

gcloud

Para eliminar un certificado SSL global, usa el comando gcloud compute ssl-certificates delete con el comando --global:

gcloud compute ssl-certificates delete CERTIFICATE_NAME \
    --global

Para eliminar un certificado SSL regional, usa el comando gcloud compute ssl-certificates delete con el comando --region:

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

Haz los cambios siguientes:

• CERTIFICATE_NAME: el nombre del certificado SSL
• REGION: a Google Cloud region

Sustituir o renovar un certificado SSL antes de que caduque

Siga estos pasos si necesita sustituir, renovar o rotar un certificado SSL:

1. Ejecuta el comando gcloud compute ssl-certificates describe del certificado actual para comprobar si está a punto de caducar.

2. Crea un recurso de certificado SSL. El nuevo certificado SSL debe tener un nombre único en el proyecto.

3. Actualiza el proxy de destino para separar el certificado SSL antiguo y añadir el nuevo. Incluye todos los demás certificados SSL que quieras conservar.

   Para evitar el tiempo de inactividad, ejecuta un solo comando gcloud con la marca --ssl-certificates. Por ejemplo:

   En el caso de los balanceadores de carga de aplicación externos globales:

   Usa el comando gcloud compute target-https-proxies update con la marca --global.

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

   En el caso de los balanceadores de carga de aplicación externos regionales y los balanceadores de carga de aplicación internos regionales:

   Usa el comando gcloud compute target-https-proxies update con la marca --region.

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

   En el caso de los balanceadores de carga de red de proxy externos:

   Usa el comando gcloud compute target-ssl-proxies update con la marca --backend-service.

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

4. Para comprobar que el balanceador de carga está usando el certificado de sustitución, ejecuta el siguiente comando de OpenSSL:

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

   Nota: Si varios certificados coinciden con el nombre de host de SNI especificado por el cliente, el balanceador de carga podría seleccionar un certificado distinto del certificado principal (el primer certificado de la lista). Para obtener más información, consulta el artículo sobre varios certificados SSL.

5. Espera 15 minutos para asegurarte de que la operación de sustitución se ha propagado a todos los front-ends de Google (GFEs).

6. Opcional: elimina el certificado SSL antiguo.

Rotar los certificados SSL periódicamente

Esta solución de ejemplo comprueba periódicamente el estado de los certificados utilizados con balanceadores de carga de Google Cloud y rota los certificados cuando alcanzan un porcentaje determinado de su tiempo de vida. La herramienta usa las ACs configuradas mediante el Servicio de Autoridades de Certificación.

Esta solución funciona con los siguientes balanceadores de carga:

• Balanceador de carga de aplicación externo global
• Balanceador de carga de aplicación clásico
• Balanceador de carga de aplicación externo regional
• Balanceador de carga de aplicación interno
• Balanceador de carga de red de proxy externo con un proxy SSL

Importante: Esta solución no es un producto oficial y no cuenta con la asistencia de Google, sino que es un ejemplo que se proporciona como referencia.

Siguientes pasos

• Para solucionar problemas con los certificados SSL, consulta el artículo Solucionar problemas de certificados SSL.