Utilizzare i certificati SSL autogestiti

I certificati SSL con gestione indipendente sono certificati che ottieni, esegui il provisioning e rinnovi autonomamente. Puoi utilizzare questa risorsa per proteggere la comunicazione tra i client e il bilanciatore del carico.

I certificati autogestiti possono essere una qualsiasi combinazione dei seguenti tipi di certificati:

• Verifica del dominio (DV)
• Convalida dell'organizzazione (OV)
• Convalida estesa (EV)

I certificati autogestiti sono supportati con i seguenti bilanciatori del carico:

• Certificati globali
  • Bilanciatore del carico delle applicazioni esterno globale
  • Bilanciatore del carico delle applicazioni classico
  • Bilanciatore del carico di rete proxy esterno (con un proxy SSL di destinazione)

• Certificati regionali
  • Bilanciatore del carico delle applicazioni esterno regionale
  • Bilanciatore del carico delle applicazioni interno regionale

Questa pagina descrive la procedura per ottenere un certificato Compute Engine valido e caricarlo per creare una risorsa del certificato SSL di Google Cloud.

Per creare certificati gestiti da Google utilizzando Certificate Manager, consulta Panoramica del deployment.

Prima di iniziare

• Assicurati di conoscere la panoramica dei certificati SSL.
• Assicurati di avere i nomi di dominio che vuoi utilizzare per il tuo certificato SSL autogestito. Se utilizzi Cloud Domains, consulta il passaggio 1: registra un nome di dominio utilizzando Cloud Domains.

Autorizzazioni

Per eseguire le attività descritte in questa guida, devi essere in grado di creare e modificare i certificati SSL nel tuo progetto. Puoi farlo se una delle seguenti condizioni è vera:

• Sei un proprietario o editor del progetto (roles/owner o roles/editor).
• Nel progetto disponi sia del ruolo Amministratore sicurezza Compute (compute.securityAdmin) sia del ruolo Amministratore rete Compute (compute.networkAdmin).
• Hai un ruolo personalizzato per il progetto che include le autorizzazioni compute.sslCertificates.* e una o entrambe le autorizzazioni compute.targetHttpsProxies.* e compute.targetSslProxies.*, a seconda del tipo di bilanciatore del carico in uso.

Passaggio 1: crea una chiave privata e un certificato

Se hai già una chiave privata e un certificato di un'autorità di certificazione (CA), salta questa sezione e vai a Creare una risorsa del certificato SSL.

Seleziona o crea una chiave privata

Un certificato SSL di Google Cloud include sia una chiave privata sia il certificato stesso, entrambi in formato PEM. La chiave privata deve soddisfare i seguenti criteri:

• Deve essere in formato PEM.
• Non può essere protetto da una passphrase. Google Cloud archivia la chiave privata nel proprio formato criptato.
• L'algoritmo di crittografia deve essere RSA-2048 o ECDSA P-256.

Per creare una nuova chiave privata, utilizza uno dei seguenti comandi OpenSSL.

• Crea una chiave privata RSA-2048:

  openssl genrsa -out PRIVATE_KEY_FILE 2048
  

• Crea una chiave privata ECDSA P-256:

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

Sostituisci PRIVATE_KEY_FILE con il percorso e il nome del nuovo file della chiave privata.

Crea una richiesta di firma del certificato (CSR)

Una volta ottenuta una chiave privata, puoi generare una richiesta di firma del certificato (CSR) in formato PEM utilizzando OpenSSL. Il tuo CSR deve soddisfare i seguenti criteri:

• Deve essere in formato PEM.
• Deve avere un attributo nome comune (CN) o nome alternativo soggetto (SAN). In pratica, il certificato deve contenere entrambi gli attributi CN e SAN, anche se si riferisce a un singolo dominio. I client moderni, come le versioni attuali di macOS e iOS, non si basano solo sull'attributo CN.

Per creare un CSR:

1. Crea un file di configurazione OpenSSL. Nell'esempio seguente, i nomi alternativi degli oggetti sono definiti in [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. Esegui il seguente comando OpenSSL per creare un file di richiesta di firma del certificato (CSR). Il comando è interattivo; ti vengono richiesti gli attributi tranne i nomi alternativi dell'oggetto, che hai definito nel [sans_list] di CONFIG_FILE nel passaggio precedente.

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

Per entrambi i passaggi, sostituisci quanto segue:

• CONFIG_FILE: il percorso, incluso il nome file, del file di configurazione OpenSSL (puoi eliminare il file al termine di questa procedura)

• SUBJECT_ALTERNATIVE_NAME_1 e SUBJECT_ALTERNATIVE_NAME_2: nomi alternativi dell'oggetto per il tuo certificato

  Se il certificato è solo per un nome host, devi solo definire un singolo nome alternativo dell'oggetto che corrisponda al nome comune. Se hai bisogno di più di due nomi alternativi per l'oggetto, aggiungili al file di configurazione, incrementando il numero dopo DNS (DNS.3, DNS.4 e così via).

• PRIVATE_KEY_FILE: il percorso del file della chiave privata

• CSR_FILE: il percorso, incluso il nome file, per il CSR

Firma la CSR

Quando un'autorità di certificazione (CA) firma la tua richiesta di firma del certificato (CSR), utilizza la propria chiave privata per creare un certificato. Per firmare la CSR, utilizza uno dei seguenti metodi:

Utilizza un'autorità di certificazione attendibile pubblicamente

Se richiedi a un'autorità di certificazione attendibile pubblica di firmare la tua CSR, il certificato risultante è considerato attendibile da tutti i client che si fidano di questa autorità di certificazione pubblica. Per produrre un certificato firmato, l'autorità di certificazione pubblica ha bisogno solo della tua CSR.

Utilizzare la propria CA interna

Se gestisci la tua CA, puoi utilizzarla per firmare la CSR. Se utilizzi la tua CA per firmare la CSR, viene creato un certificato attendibile internamente se i tuoi client sono stati configurati anche per considerare attendibile la tua CA.

Utilizza un certificato autofirmato

Se utilizzi la stessa chiave privata utilizzata per creare la CSR per firmarla, hai creato un certificato autofirmato. Devi utilizzare i certificati autofirmati solo per i test.

Google Cloud non supporta la verifica lato client per i certificati server autofirmati. Pertanto, devi configurare il client in modo da saltare la convalida del certificato. Ad esempio, puoi creare un client del browser web che visualizza un messaggio che ti chiede se vuoi considerare attendibile un certificato autofirmato.

Se gestisci la tua CA o se vuoi creare un certificato autofirmato per i test, puoi utilizzare il seguente comando OpenSSL:

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

Sostituisci quanto segue:

• PRIVATE_KEY_FILE: il percorso della chiave privata per la tua CA. Se crei un certificato autofirmato per i test, questa chiave privata è la stessa utilizzata per creare la CSR
• CSR_FILE: il percorso del file CSR
• CERTIFICATE_FILE: il percorso del file del certificato da creare
• TERM: il numero di giorni a partire da oggi durante i quali il certificato deve essere considerato valido dai clienti che lo verificano

Caratteri jolly nei nomi comuni

I certificati SSL con gestione indipendente possono utilizzare un carattere jolly nel nome comune. Ad esempio, un certificato con il nome comune *.example.com. corrisponde ai nomi host www.example.com e foo.example.com, ma non a a.b.example.com o example.com. Quando il bilanciatore del carico seleziona un certificato, preferisce sempre associare un nome host ai certificati senza caratteri jolly rispetto ai certificati con caratteri jolly.

I certificati con frammenti con caratteri jolly, come f*.example.com, non sono supportati.

Passaggio 2: crea una risorsa del certificato SSL autogestita

Prima di poter creare una risorsa del certificato SSL Google Cloud, devi avere una chiave privata e un certificato. Consulta la sezione Creare una chiave privata e un certificato se non li hai già creati o ottenuti.

Dopo aver creato un certificato, non puoi modificarne l'ambito da globale a regionale o da regionale a globale.

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

Passaggio 3: associa un certificato SSL a un proxy di destinazione

Devi associare almeno un certificato SSL a ogni proxy HTTPS o SSL di destinazione. Puoi configurare il proxy di destinazione con un massimo di numero massimo di certificati SSL per proxy SSL di destinazione o HTTPS di destinazione. Puoi fare riferimento a più certificati gestiti autonomamente nello stesso proxy di destinazione.

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
}

Passaggio 4: aggiorna i record DNS A e AAAA in modo che puntino all'indirizzo IP del bilanciatore del carico

Sul sito del tuo registrar, sull'host DNS o sull'ISP (ovunque siano gestiti i tuoi record DNS), aggiungi o aggiorna i record A DNS (per IPv4) e i record AAAA DNS (per IPv6) per i tuoi domini e eventuali sottodomini in modo che rimandino all'indirizzo IP associato alla regola o alle regole di regola di forwarding del bilanciatore del carico.

Se utilizzi Cloud DNS e Cloud Domains, configura i tuoi domini e aggiorna i tuoi server dei nomi.

Se utilizzi più domini per un singolo certificato, devi aggiungere o aggiornare i record DNS per tutti i domini e gli eventuali sottodomini in modo che tutti rimandino all'indirizzo IP del bilanciatore del carico.

Dopo aver atteso il completamento della propagazione DNS, puoi verificare la configurazione eseguendo il comando dig. Ad esempio, supponiamo che il tuo dominio sia www.example.com. Esegui questo 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

In questo esempio, 203.0.113.5 è l'indirizzo IP del bilanciatore del carico.

Passaggio 5: esegui il test con OpenSSL

Potrebbero essere necessari fino a 30 minuti prima che il bilanciatore del carico inizi a utilizzare il tuo certificato SSL con gestione indipendente.

Per eseguire il test, esegui il seguente comando OpenSSL, sostituendo DOMAIN con il tuo nome DNS e IP_ADDRESS con l'indirizzo IP del bilanciatore del carico.

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

Questo comando stampa i certificati che il bilanciatore del carico presenta al client. Oltre ad altre informazioni dettagliate, l'output deve includere la catena di certificati e Verify return code: 0 (ok).

Utilizzare i certificati SSL con gestione indipendente

Le sezioni riportate di seguito descrivono come elencare, visualizzare, eliminare e sostituire le risorse dei certificati SSL.

Elenca certificati SSL

gcloud compute ssl-certificates list \
   --global

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

Descrivere i certificati SSL

gcloud  compute ssl-certificates describe CERTIFICATE_NAME \
   --global

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

Elimina certificati SSL

Prima di poter eliminare un certificato SSL, devi prima aggiornare ogni proxy di destinazione che fa riferimento al certificato. Per ogni proxy di destinazione, esegui il comando gcloud update appropriato per aggiornare il SSL_CERTIFICATE_LIST del proxy di destinazione in modo che non includa più il certificato SSL da eliminare. Ogni proxy SSL di destinazione o proxy HTTPS di destinazione deve fare riferimento ad almeno un certificato SSL.

Dopo aver aggiornato il proxy di destinazione, puoi eliminare il certificato SSL.

gcloud compute ssl-certificates delete CERTIFICATE_NAME \
    --global

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

Sostituire o rinnovare un certificato SSL prima della scadenza

Segui questi passaggi se devi sostituire, rinnovare o ruotare un certificato SSL:

1. Esegui il comando gcloud compute ssl-certificates describe per il certificato corrente per verificare se sta per scadere.

2. Crea una nuova risorsa del certificato SSL. Il nuovo certificato SSL deve avere un nome univoco all'interno del progetto.

3. Aggiorna il proxy di destinazione per scollegare il vecchio certificato SSL e aggiungere quello nuovo. Assicurati di includere eventuali altri certificati SSL esistenti che vuoi conservare.

   Per evitare i tempi di riposo, esegui un singolo comando gcloud con il flag --ssl-certificates. Ad esempio:

   Per i bilanciatori del carico delle applicazioni esterni globali:

   Utilizza il comando gcloud compute target-https-proxies update con il flag --global.

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

   Per i bilanciatori del carico delle applicazioni esterni e interni regionali:

   Utilizza il comando gcloud compute target-https-proxies update con il flag --region.

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

   Per i bilanciatori del carico di rete proxy esterni:

   Utilizza il comando gcloud compute target-ssl-proxies update con il flag --backend-service.

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

4. Verifica che il bilanciatore del carico gestisca il certificato sostitutivo eseguendo il seguente comando OpenSSL:

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

5. Attendi 15 minuti per assicurarti che l'operazione di sostituzione sia stata propagata a tutti i front-end di Google.

6. (Facoltativo) Elimina il vecchio certificato SSL.

Ruota periodicamente i certificati SSL

Questa soluzione di esempio controlla periodicamente lo stato dei certificati utilizzati con i bilanciatori del carico Google Cloud e li ruota quando raggiungono una determinata percentuale della loro durata. Lo strumento utilizza le CA configurate utilizzando il servizio Certificate Authority.

Questa soluzione è compatibile con i seguenti bilanciatori del carico:

• Bilanciatore del carico delle applicazioni esterno globale
• Bilanciatore del carico delle applicazioni classico
• Bilanciatore del carico delle applicazioni esterno regionale
• Bilanciatore del carico delle applicazioni interno
• Bilanciatore del carico di rete proxy esterno con un proxy SSL

Passaggi successivi

• Per risolvere i problemi relativi ai certificati SSL, consulta Risoluzione dei problemi relativi ai certificati SSL.