Utilizzare certificati SSL autogestiti

I certificati SSL autogestiti sono certificati che ottieni, di cui esegui il provisioning e che rinnovi personalmente. 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 certificato:

• Convalida del dominio (DV)
• Convalida dell'organizzazione (OV)
• Extended Validation (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 poi caricarlo per creare una risorsa certificato SSL. Google Cloud

Per creare certificati gestiti da Google utilizzando Certificate Manager, consulta la panoramica dell'implementazione.

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 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 hai sia il ruolo Compute Security Admin (compute.securityAdmin) sia il ruolo Compute Network Admin (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 che utilizzi.

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 Creazione di una risorsa del certificato SSL.

Seleziona o crea una chiave privata

Un certificato SSL 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 Memorizza la tua chiave privata in un formato criptato.
• Il suo algoritmo di crittografia deve essere RSA o ECDSA. Per sapere quali tipi di chiavi puoi utilizzare, consulta la sezione Tipi di chiavi supportati.

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 file della nuova chiave privata.

Creare una richiesta di firma del certificato (CSR)

Dopo aver ottenuto una chiave privata, puoi generare una richiesta di firma del certificato (CSR) in formato PEM utilizzando OpenSSL. La tua CSR deve soddisfare i seguenti criteri:

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

Per creare una richiesta di firma del certificato:

1. Crea un file di configurazione OpenSSL. Nel seguente esempio, i nomi alternativi del soggetto 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 questo comando OpenSSL per creare un file di richiesta di firma del certificato (CSR). Il comando è interattivo: ti viene chiesto di inserire gli attributi tranne i nomi alternativi del soggetto, che hai definito in [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 dopo aver completato questa procedura)

• SUBJECT_ALTERNATIVE_NAME_1 e SUBJECT_ALTERNATIVE_NAME_2: nomi alternativi del soggetto per il tuo certificato

  Se il certificato è valido solo per un nome host, devi definire un solo nome alternativo del soggetto che corrisponda al nome comune. Se hai bisogno di più di due nomi alternativi del soggetto, 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 la CSR

Firma la CSR

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

Utilizzare un'autorità di certificazione attendibile pubblicamente

Se richiedi a una CA attendibile pubblicamente di firmare la tua CSR, il certificato risultante è considerato attendibile da tutti i client che si fidano di quella CA pubblica. Per produrre un certificato firmato, la CA pubblica ha bisogno solo della tua CSR.

Utilizzare la propria CA interna

Se gestisci una CA, puoi utilizzarla per firmare la CSR. L'utilizzo della tua CA per firmare la CSR crea un certificato attendibile internamente quando anche i tuoi client sono stati configurati per considerare attendibile la tua CA.

Utilizza un certificato autofirmato

Se utilizzi la stessa chiave privata che hai utilizzato per creare la richiesta 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 che ignori la convalida del certificato. Ad esempio, puoi creare un client browser web che mostri 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 della 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 client che lo verificano

Caratteri jolly nei nomi comuni

I certificati SSL autogestiti 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 abbinare un nome host a certificati senza caratteri jolly rispetto a certificati con caratteri jolly.

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

Passaggio 2: crea una risorsa del certificato SSL autogestito

Prima di poter creare una risorsa del certificato SSL, devi disporre di una chiave privata e di un certificato. Google Cloud Consulta Creazione di una chiave privata e di un certificato se non li hai ancora 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

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

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

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

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

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

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

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

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

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

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

      return sslCert;
    }
  }
}

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

from googleapiclient import discovery


def create_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 SSL o HTTPS di destinazione. Puoi configurare il proxy di destinazione con un massimo di il numero massimo di certificati SSL per proxy SSL di destinazione o HTTPS di destinazione. Puoi fare riferimento a più certificati autogestiti 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 A e AAAA del DNS in modo che puntino all'indirizzo IP del bilanciatore del carico

Sul sito del registrar, dell'host DNS o dell'ISP (ovunque siano gestiti i record DNS), aggiungi o aggiorna i record A DNS (per IPv4) e i record AAAA DNS (per IPv6) per i tuoi domini e sottodomini in modo che puntino all'indirizzo IP associato alla regola o alle regole 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 i sottodomini in modo che puntino tutti 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 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 restituisce 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 autogestiti

Le sezioni seguenti 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 che devi 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

Sostituisci o rinnova un certificato SSL prima che scada

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

1. Esegui il comando gcloud compute ssl-certificates describe per il certificato attuale 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 tempi di inattività, 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 regionali e i bilanciatori del carico delle applicazioni 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 stia utilizzando 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 Google Front End (GFE).

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 tramite Certificate Authority Service.

Questa soluzione funziona 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, vedi Risoluzione dei problemi relativi ai certificati SSL.