Usa certificados SSL autoadministrados

Los certificados SSL autoadministrados son certificados que obtienes, aprovisionas y renuevas tú mismo. Además, puedes usar este recurso para proteger la comunicación entre los clientes y el balanceador de cargas.

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

• Validación de dominio (DV)
• Validación de organización (OV)
• Validación extendida (EV)

Los certificados autoadministrados son compatibles con los siguientes balanceadores de cargas:

• Certificados globales
  • Balanceador de cargas de aplicaciones externo global
  • Balanceador de cargas de aplicaciones clásico
  • Balanceador de cargas de red del proxy externo (con un proxy SSL de destino)
• Certificados regionales
  • Balanceador de cargas de aplicaciones externo regional
  • Balanceador de cargas de aplicaciones interno

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

Para crear certificados administrados por Google mediante el Administrador de certificados, consulta Descripción general de la implementación.

Antes de comenzar

• Asegúrate de estar familiarizado con la descripción general de los certificados SSL.
• Asegúrate de tener los nombres de dominio que deseas usar para el certificado SSL autoadministrado. Si usas Cloud Domains, consulta 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 hacer esto si se cumple una de las siguientes condiciones:

• Eres propietario o editor del proyecto (roles/owner o roles/editor).
• Tienes la función de Administrador de seguridad de Compute (compute.securityAdmin) y la función de administrador de red de Compute (compute.networkAdmin) en el proyecto.
• Tienes una función personalizada para el proyecto que incluye los permisos compute.sslCertificates.*, y compute.targetHttpsProxies.* o compute.targetSslProxies.* o ambos, según el tipo de balanceador de cargas que uses.

Paso 1: Crea una clave privada y un certificado

Si ya tienes una clave privada y un certificado de una autoridad certificada (CA), omite esta sección y dirígete a Crea un recurso de certificado SSL.

Selecciona o crea una clave privada

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

• Debe estar en formato PEM.
• No se puede proteger con una frase de contraseña. Google Cloud almacena tu clave privada en su propio formato encriptado.
• Su algoritmo de encriptación debe ser RSA-2048 o ECDSA P-256.

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

• Crea una clave privada RSA-2048:

  openssl genrsa -out PRIVATE_KEY_FILE 2048
  

• Crea una clave privada ECDSA P-256:

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

Reemplaza PRIVATE_KEY_FILE por la ruta y el nombre de archivo del archivo de claves privadas nuevo.

Crea una solicitud de firma de certificado (CSR)

Después de obtener una clave privada, puedes generar una solicitud de firma de certificado (CSR) en formato PEM mediante OpenSSL. La CSR debe cumplir con los siguientes criterios:

• Debe estar en formato PEM.
• Debe tener un atributo de nombre común (CN) o uno de nombre alternativo de entidad (SAN). En términos prácticos, el certificado debe contener ambos atributos, CN y SAN, incluso si se trata de clientes de un solo dominio moderno, como las versiones actuales de iOS y macOS que no dependen solo del atributo CN.

Para crear una CSR, sigue estos pasos:

1. Crea un archivo de configuración de OpenSSL. En el siguiente ejemplo, los nombres alternativos de 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 compilar un archivo de solicitud de firma de certificado (CSR). El comando es interactivo; se solicitarán atributos excepto para los nombres alternativos del sujeto, que se definieron en [sans_list] de CONFIG_FILE en el paso anterior.

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

Para ambos pasos, reemplaza lo siguiente:

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

• SUBJECT_ALTERNATIVE_NAME_1 y SUBJECT_ALTERNATIVE_NAME_2: son nombres alternativos de entidad para tu certificado

  Si el certificado es solo para un nombre de host, solo debes definir un nombre alternativo de entidad única que coincida con el nombre común. Si necesitas más de dos nombres alternativos de entidad, agrégalos al archivo de configuración y aumenta el número después de DNS (DNS.3, DNS.4, etcétera).

• PRIVATE_KEY_FILE: es la ruta de acceso al archivo de claves privadas.

• CSR_FILE: es la ruta de acceso, incluido el nombre del archivo, para la CSR.

Firma la CSR

Cuando una autoridad certificada (CA) firma tu CSR, usa su propia clave privada para crear un certificado. Usa uno de los siguientes métodos para firmar la CSR:

Usa una CA de confianza pública

Si solicitas que una CA de confianza pública firme tu CSR, todos los clientes que confían en esa CA pública confían en el certificado resultante. Para producir un certificado firmado, la CA pública solo necesita tu CSR.

Usa tu propia CA interna

Si administras tu propia CA, puedes usarla para firmar la CSR. Si usas tu CA para firmar tu CSR, se crea un certificado de confianza interna cuando tus clientes también se configuraron para confiar en tu propia CA.

Usar un certificado autofirmado

Si usas la misma clave privada que usaste para crear la CSR para firmarla, creaste un certificado autofirmado. Solo debes usar certificados autofirmados para las pruebas.

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

Si administras tu propia CA o deseas crear un certificado autofirmado para 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

Reemplaza lo siguiente:

• PRIVATE_KEY_FILE: es la ruta de acceso a la clave privada de tu CA. Si se crea un certificado autofirmado para pruebas, esta clave privada es la misma que se usó a fin de crear la CSR.
• CSR_FILE: es la ruta de acceso a la CSR.
• CERTIFICATE_FILE: es la ruta de acceso al archivo del certificado que se creará.
• TERM: es la cantidad de días, a partir de ahora, durante los cuales los clientes que lo verifican deben considerarlo válido.

Comodines en nombres comunes

Los certificados SSL autoadministrados 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 example.com. Cuando el balanceador de cargas selecciona un certificado, siempre prefiere hacer coincidir un nombre de host con certificados sin comodines, en vez de certificados con comodines.

Los certificados con fragmentos de comodines, como f*.example.com, no son compatibles.

Paso 2: Crea un recurso de certificado SSL autoadministrado

Antes de crear un recurso de certificado SSL de Google Cloud, debes tener una clave privada y un certificado. Consulta Crea una clave privada y un certificado si aún no los creaste ni obtuviste.

Después de crear un certificado, no puedes cambiar su alcance de global a regional, o de regional a global.

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

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

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

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

Paso 3: Asocia un certificado SSL con un proxy de destino

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

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

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

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

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
}

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

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

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 AAAA y A del DNS para que apunten a la dirección IP del balanceador de cargas

En el host DNS, el ISP o el sitio de tu registrador (donde sea que se administren los registros DNS), agrega o actualiza los registros A (IPv4) y los registros AAAA (IPv6) del DNS de los dominios y de cualquier subdominio, a fin de que apunten a la dirección IP asociada con la regla o las reglas de reenvío del balanceador de cargas.

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

Si usas varios dominios para un solo certificado, debes agregar o actualizar los registros DNS de todos los dominios y los subdominios a fin de que todos apunten a la dirección IP del balanceador de cargas.

Después de esperar a que se complete la propagación del DNS, puedes ejecutar el comando dig para verificar la configuración. Por ejemplo, supongamos que el 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 del balanceador de cargas.

Paso 5: Prueba con OpenSSL

El balanceador de cargas puede tardar hasta 30 minutos en comenzar a usar el certificado SSL autoadministrado.

Para probar ejecuta el siguiente comando de OpenSSL y reemplaza DOMAIN por el nombre del DNS y IP_ADDRESS por la dirección IP del balanceador de cargas.

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

Este comando da como resultado los certificados que el balanceador de cargas presenta al cliente. Junto con otra información detallada, el resultado debe incluir la cadena de certificados y Verify return code: 0 (ok).

Trabaja con certificados SSL autoadministrados

En las siguientes secciones, se describe cómo enumerar, ver, borrar y reemplazar recursos de certificados SSL.

Mostrar lista de certificados SSL

gcloud compute ssl-certificates list \
   --global

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

Describe certificados SSL

gcloud  compute ssl-certificates describe CERTIFICATE_NAME \
   --global

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

Borrar certificados SSL

Antes de borrar un certificado SSL, primero debes actualizar cada proxy de destino que haga referencia al certificado. En cada proxy de destino, ejecuta el comando gcloud update adecuado para actualizar la SSL_CERTIFICATE_LIST del proxy de destino para que ya no incluya el certificado SSL que necesitas borrar. Cada proxy SSL o HTTPS de destino debe hacer referencia, por lo menos, a un certificado SSL.

Después de actualizar el proxy de destino, puedes borrar el certificado SSL.

gcloud compute ssl-certificates delete CERTIFICATE_NAME \
    --global

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

Reemplaza o renueva un certificado SSL antes de que venza

Sigue estos pasos si necesitas reemplazar, renovar o rotar un certificado SSL:

1. Ejecuta el comando gcloud compute ssl-certificates describe para el certificado actual a fin de verificar si está a punto de vencer.

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

3. Actualiza el proxy de destino para desconectar el certificado SSL anterior y agregar el nuevo. Asegúrate de incluir cualquier otro certificado SSL existente que quieras conservar.

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

   Balanceadores de cargas de aplicaciones globales externos:

   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
   

   Para balanceadores de cargas de aplicaciones regionales y externos:

   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 \
      --global-ssl-certificates
   

   Balanceadores de cargas 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. Ejecuta el siguiente comando de OpenSSL para verificar que el balanceador de cargas entregue el certificado de reemplazo:

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

5. Espera 15 minutos para asegurarte de que la operación de reemplazo se haya propagado a todos los Google Front Ends (GFEs).

6. Borra el certificado SSL anterior (opcional).

Rota certificados SSL periódicamente

Esta solución de muestra verifica de forma periódica el estado de los certificados que se usan con los balanceadores de cargas de Google Cloud y rota los certificados cuando alcanzan un porcentaje determinado de su vida útil. La herramienta usa CA configuradas mediante Certificate Authority Service.

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

• Balanceador de cargas de aplicaciones externo global
• Balanceador de cargas de aplicaciones clásico
• Balanceador de cargas de aplicaciones externo regional
• Balanceador de cargas de aplicaciones interno
• Balanceador de cargas de red del proxy externo con un proxy SSL

¿Qué sigue?

• Para solucionar problemas de certificados SSL, consulta Soluciona problemas con los certificados SSL.