Questa pagina è stata tradotta dall'API Cloud Translation.

Crea un'autorità di certificazione subordinata

Questa pagina descrive come creare autorità di certificazione (CA) subordinate in un pool di CA.

Le CA subordinate sono responsabili dell'emissione di certificati direttamente alle persone giuridiche finali, come utenti, computer e dispositivi. Le CA subordinate sono firmate in modo criptato da una CA principale, che spesso è la CA radice. Di conseguenza, i sistemi che ritengono attendibile la CA radice ritengono automaticamente attendibili le CA subordinate e i certificati delle entità finali emessi dalle CA subordinate.

Prima di iniziare

Assicurati di disporre del ruolo IAM Responsabile operativo servizio CA (roles/privateca.caManager) o Amministratore servizio CA (roles/privateca.admin). Per informazioni, consulta Configurare i criteri IAM.
Crea un pool di CA.
Seleziona la CA principale.

Creare una CA subordinata

Le CA subordinate sono più facili da revocare e ruotare rispetto alle CA radice. Se hai più scenari di rilascio di certificati, puoi creare una CA subordinata per ciascuno di questi scenari. L'aggiunta di più CA subordinate in un pool di CA consente di bilanciare meglio il carico delle richieste di certificato e di ottenere un QPS effettivo totale più elevato.

Per creare una CA subordinata:

Console

Vai alla pagina Certificate Authority Service nella console Google Cloud.

Vai a Certificate Authority Service
Fai clic sulla scheda Gestore CA.
Fai clic su Crea CA.

Seleziona il tipo di CA

Fai clic su CA subordinata.
Fai clic su La CA radice si trova in Google Cloud.
Nel campo Valido per, inserisci la durata per la quale vuoi che il certificato dell'autorità di certificazione sia valido.
(Facoltativo) Scegli il livello della CA. Il livello predefinito è Enterprise. Per ulteriori informazioni, vedi Selezionare i livelli di operazioni.
Fai clic su Regione per selezionare una località per la CA. Per ulteriori informazioni, consulta Località.
(Facoltativo) In Stato inizializzato, seleziona lo stato in cui deve essere l'autorità di certificazione al momento della creazione.
(Facoltativo) In Configura uno scenario di emissione, fai clic su Profilo del certificato e seleziona dall'elenco il profilo del certificato più adatto alle tue esigenze. Per scoprire di più, consulta la sezione Profili dei certificati.
Fai clic su Avanti.

Configura il nome oggetto della CA

Nel campo Organizzazione (O), inserisci il nome della tua azienda.
(Facoltativo) Nel campo Unità organizzativa (OU), inserisci la suddivisione dell'azienda o la business unit.
(Facoltativo) Nel campo Nome paese, inserisci un codice paese di due lettere.
(Facoltativo) Nel campo Nome stato o provincia, inserisci il nome del tuo stato.
(Facoltativo) Nel campo Nome località, inserisci il nome della tua città.
Nel campo Nome comune CA (CN), inserisci il nome della CA.
Nel campo ID pool, inserisci il nome del pool di CA. Non puoi modificare il pool di CA dopo aver creato la CA.
Fai clic su Avanti.

Configura dimensioni e algoritmo della chiave CA

Scegli l'algoritmo chiave più adatto alle tue esigenze. Per informazioni su come scegliere l'algoritmo chiave più adatto, consulta Scegliere un algoritmo chiave.
Fai clic su Avanti.

Configurare gli elementi CA

I passaggi che seguono sono facoltativi. Se salti questi passaggi, verranno applicate le impostazioni predefinite.

Scegli se utilizzare un bucket Cloud Storage gestito da Google o autogestito.

Se non selezioni un bucket Cloud Storage autogestito, il servizio CA crea un bucket gestito da Google nella stessa posizione dell'autorità di certificazione.

Scegli se disattivare la pubblicazione degli elenchi di revoche dei certificati (CRL) e dei certificati CA nel bucket Cloud Storage.

La pubblicazione di CRL e certificato CA in un bucket Cloud Storage è abilitata per impostazione predefinita. Per disattivare queste impostazioni, fai clic sui pulsanti di attivazione/disattivazione.

Fai clic su Avanti.

Aggiungere etichette

I passaggi che seguono sono facoltativi.

Se vuoi aggiungere etichette alla CA:

Fai clic su Aggiungi elemento.
Nel campo Chiave 1, inserisci la chiave dell'etichetta.
Nel campo Valore 1, inserisci il valore dell'etichetta.
Se vuoi aggiungere un'altra etichetta, fai clic su Aggiungi elemento. Aggiungi poi la chiave e il valore dell'etichetta come indicato nei passaggi 2 e 3.
Fai clic su Avanti.

Rivedi le impostazioni

Esamina attentamente tutte le impostazioni, quindi fai clic su Crea per creare la CA.

gcloud

Crea un pool di CA per la CA subordinata:
```
gcloud privateca pools create SUBORDINATE_POOL_ID
```
Sostituisci SUBORDINATE_POOL_ID con il nome del pool di CA.

Per ulteriori informazioni sulla creazione di pool di CA, consulta Creare un pool di CA.

Per ulteriori informazioni sul comando gcloud privateca pools create, consulta gcloud privateca pools create.
Crea una CA subordinata nel pool di CA creato.

Nota: puoi ottenere l'ID risorsa (POOL_ID) dell'emittente copiando l'ID dal comando create o utilizzando il comando gcloud privateca pools list.
```
gcloud privateca subordinates create SUBORDINATE_CA_ID \
  --pool=SUBORDINATE_POOL_ID \
  --issuer-pool=POOL_ID \
  --key-algorithm="ec-p256-sha256" \
  --subject="CN=Example Server TLS CA, O=Example LLC"
```
Quando viene creata la CA subordinata, viene restituita la seguente dichiarazione.
```
Created Certificate Authority [projects/my-project-pki/locations/us-west1/caPools/SUBORDINATE_POOL_ID/certificateAuthorities/SUBORDINATE_CA_ID].
```
Per visualizzare un elenco esaustivo delle impostazioni, esegui il seguente comando gcloud:
```
gcloud privateca subordinates create --help
```
Il comando restituisce esempi per creare una CA subordinata il cui emittente si trova nel servizio CA o altrove.

Terraform

resource "google_privateca_certificate_authority" "root_ca" {
  // This example assumes this pool already exists.
  // Pools cannot be deleted in normal test circumstances, so we depend on static pools
  pool                                   = "my-pool"
  certificate_authority_id               = "my-certificate-authority-root"
  location                               = "us-central1"
  deletion_protection                    = false # set to true to prevent destruction of the resource
  ignore_active_certificates_on_deletion = true
  config {
    subject_config {
      subject {
        organization = "ACME"
        common_name  = "my-certificate-authority"
      }
    }
    x509_config {
      ca_options {
        # is_ca *MUST* be true for certificate authorities
        is_ca = true
      }
      key_usage {
        base_key_usage {
          # cert_sign and crl_sign *MUST* be true for certificate authorities
          cert_sign = true
          crl_sign  = true
        }
        extended_key_usage {
        }
      }
    }
  }
  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
  // valid for 10 years
  lifetime = "${10 * 365 * 24 * 3600}s"
}

resource "google_privateca_certificate_authority" "sub_ca" {
  // This example assumes this pool already exists.
  // Pools cannot be deleted in normal test circumstances, so we depend on static pools
  pool                     = "my-sub-pool"
  certificate_authority_id = "my-certificate-authority-sub"
  location                 = "us-central1"
  deletion_protection      = false # set to true to prevent destruction of the resource
  subordinate_config {
    certificate_authority = google_privateca_certificate_authority.root_ca.name
  }
  config {
    subject_config {
      subject {
        organization = "ACME"
        common_name  = "my-subordinate-authority"
      }
    }
    x509_config {
      ca_options {
        is_ca = true
        # Force the sub CA to only issue leaf certs.
        # Use e.g.
        #    max_issuer_path_length = 1
        # if you need to chain more subordinates.
        zero_max_issuer_path_length = true
      }
      key_usage {
        base_key_usage {
          cert_sign = true
          crl_sign  = true
        }
        extended_key_usage {
        }
      }
    }
  }
  // valid for 5 years
  lifetime = "${5 * 365 * 24 * 3600}s"
  key_spec {
    algorithm = "RSA_PKCS1_2048_SHA256"
  }
  type = "SUBORDINATE"
}

Java

Per autenticarti al servizio CA, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.


import com.google.api.core.ApiFuture;
import com.google.cloud.security.privateca.v1.CaPoolName;
import com.google.cloud.security.privateca.v1.CertificateAuthority;
import com.google.cloud.security.privateca.v1.CertificateAuthority.KeyVersionSpec;
import com.google.cloud.security.privateca.v1.CertificateAuthority.SignHashAlgorithm;
import com.google.cloud.security.privateca.v1.CertificateAuthorityServiceClient;
import com.google.cloud.security.privateca.v1.CertificateConfig;
import com.google.cloud.security.privateca.v1.CertificateConfig.SubjectConfig;
import com.google.cloud.security.privateca.v1.CreateCertificateAuthorityRequest;
import com.google.cloud.security.privateca.v1.KeyUsage;
import com.google.cloud.security.privateca.v1.KeyUsage.KeyUsageOptions;
import com.google.cloud.security.privateca.v1.Subject;
import com.google.cloud.security.privateca.v1.SubjectAltNames;
import com.google.cloud.security.privateca.v1.X509Parameters;
import com.google.cloud.security.privateca.v1.X509Parameters.CaOptions;
import com.google.longrunning.Operation;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class CreateSubordinateCa {

  public static void main(String[] args)
      throws InterruptedException, ExecutionException, IOException {
    // TODO(developer): Replace these variables before running the sample.
    // location: For a list of locations, see:
    // https://cloud.google.com/certificate-authority-service/docs/locations
    // poolId: Set it to the CA Pool under which the CA should be created.
    // subordinateCaName: Unique name for the Subordinate CA.
    String project = "your-project-id";
    String location = "ca-location";
    String poolId = "ca-pool-id";
    String subordinateCaName = "subordinate-certificate-authority-name";

    createSubordinateCertificateAuthority(project, location, poolId, subordinateCaName);
  }

  public static void createSubordinateCertificateAuthority(
      String project, String location, String poolId, String subordinateCaName)
      throws IOException, ExecutionException, InterruptedException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `certificateAuthorityServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (CertificateAuthorityServiceClient certificateAuthorityServiceClient =
        CertificateAuthorityServiceClient.create()) {

      String commonName = "commonname";
      String orgName = "csr-org-name";
      String domainName = "dns.example.com";
      int caDuration = 100000; // Validity of this CA in seconds.

      // Set the type of Algorithm.
      KeyVersionSpec keyVersionSpec =
          KeyVersionSpec.newBuilder().setAlgorithm(SignHashAlgorithm.RSA_PKCS1_4096_SHA256).build();

      // Set CA subject config.
      SubjectConfig subjectConfig =
          SubjectConfig.newBuilder()
              .setSubject(
                  Subject.newBuilder().setCommonName(commonName).setOrganization(orgName).build())
              // Set the fully qualified domain name.
              .setSubjectAltName(SubjectAltNames.newBuilder().addDnsNames(domainName).build())
              .build();

      //  Set the key usage options for X.509 fields.
      X509Parameters x509Parameters =
          X509Parameters.newBuilder()
              .setKeyUsage(
                  KeyUsage.newBuilder()
                      .setBaseKeyUsage(
                          KeyUsageOptions.newBuilder().setCrlSign(true).setCertSign(true).build())
                      .build())
              .setCaOptions(CaOptions.newBuilder().setIsCa(true).build())
              .build();

      // Set certificate authority settings.
      CertificateAuthority subCertificateAuthority =
          CertificateAuthority.newBuilder()
              .setType(CertificateAuthority.Type.SUBORDINATE)
              .setKeySpec(keyVersionSpec)
              .setConfig(
                  CertificateConfig.newBuilder()
                      .setSubjectConfig(subjectConfig)
                      .setX509Config(x509Parameters)
                      .build())
              // Set the CA validity duration.
              .setLifetime(Duration.newBuilder().setSeconds(caDuration).build())
              .build();

      // Create the CertificateAuthorityRequest.
      CreateCertificateAuthorityRequest subCertificateAuthorityRequest =
          CreateCertificateAuthorityRequest.newBuilder()
              .setParent(CaPoolName.of(project, location, poolId).toString())
              .setCertificateAuthorityId(subordinateCaName)
              .setCertificateAuthority(subCertificateAuthority)
              .build();

      // Create Subordinate CA.
      ApiFuture<Operation> futureCall =
          certificateAuthorityServiceClient
              .createCertificateAuthorityCallable()
              .futureCall(subCertificateAuthorityRequest);

      Operation response = futureCall.get();

      if (response.hasError()) {
        System.out.println("Error while creating Subordinate CA !" + response.getError());
        return;
      }

      System.out.println(
          "Subordinate Certificate Authority created successfully : " + subordinateCaName);
    }
  }
}

Python

Per autenticarti al servizio CA, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import google.cloud.security.privateca_v1 as privateca_v1
from google.protobuf import duration_pb2


def create_subordinate_ca(
    project_id: str,
    location: str,
    ca_pool_name: str,
    subordinate_ca_name: str,
    common_name: str,
    organization: str,
    domain: str,
    ca_duration: int,
) -> None:
    """
    Create Certificate Authority (CA) which is the subordinate CA in the given CA Pool.
    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        location: location you want to use. For a list of locations, see: https://cloud.google.com/certificate-authority-service/docs/locations.
        ca_pool_name: set it to the CA Pool under which the CA should be created.
        subordinate_ca_name: unique name for the Subordinate CA.
        common_name: a title for your certificate authority.
        organization: the name of your company for your certificate authority.
        domain: the name of your company for your certificate authority.
        ca_duration: the validity of the certificate authority in seconds.
    """

    ca_service_client = privateca_v1.CertificateAuthorityServiceClient()

    # Set the type of Algorithm
    key_version_spec = privateca_v1.CertificateAuthority.KeyVersionSpec(
        algorithm=privateca_v1.CertificateAuthority.SignHashAlgorithm.RSA_PKCS1_4096_SHA256
    )

    # Set CA subject config.
    subject_config = privateca_v1.CertificateConfig.SubjectConfig(
        subject=privateca_v1.Subject(
            common_name=common_name, organization=organization
        ),
        # Set the fully qualified domain name.
        subject_alt_name=privateca_v1.SubjectAltNames(dns_names=[domain]),
    )

    # Set the key usage options for X.509 fields.
    x509_parameters = privateca_v1.X509Parameters(
        key_usage=privateca_v1.KeyUsage(
            base_key_usage=privateca_v1.KeyUsage.KeyUsageOptions(
                crl_sign=True,
                cert_sign=True,
            )
        ),
        ca_options=privateca_v1.X509Parameters.CaOptions(
            is_ca=True,
        ),
    )

    # Set certificate authority settings.
    certificate_authority = privateca_v1.CertificateAuthority(
        type_=privateca_v1.CertificateAuthority.Type.SUBORDINATE,
        key_spec=key_version_spec,
        config=privateca_v1.CertificateConfig(
            subject_config=subject_config,
            x509_config=x509_parameters,
        ),
        # Set the CA validity duration.
        lifetime=duration_pb2.Duration(seconds=ca_duration),
    )

    ca_pool_path = ca_service_client.ca_pool_path(project_id, location, ca_pool_name)

    # Create the CertificateAuthorityRequest.
    request = privateca_v1.CreateCertificateAuthorityRequest(
        parent=ca_pool_path,
        certificate_authority_id=subordinate_ca_name,
        certificate_authority=certificate_authority,
    )

    operation = ca_service_client.create_certificate_authority(request=request)
    result = operation.result()

    print(f"Operation result: {result}")

Attivare una CA subordinata

Per attivare una CA subordinata:

Console

Vai alla pagina Certificate Authority Service nella console Google Cloud.

Vai a Certificate Authority Service
Fai clic sulla scheda Gestore CA.
In Autorità di certificazione, seleziona l'autorità di certificazione che vuoi attivare.
Fai clic su Attiva.
Nella finestra di dialogo visualizzata, fai clic su Scarica CSR per scaricare il file CSR con codifica PEM che la CA emittente può firmare.
Fai clic su Avanti.
Nel campo Carica la catena di certificati, fai clic su Sfoglia.
Carica il file del certificato firmato con estensione .crt.
Fai clic su Attiva.

gcloud

Per attivare una CA secondaria appena creata, esegui il seguente comando:

gcloud privateca subordinates enable SUBORDINATE_CA_ID --pool=SUBORDINATE_POOL_ID

Sostituisci quanto segue:

SUBORDINATE_CA_ID: l'identificatore univoco della CA subordinata.
SUBORDINATE_POOL_ID: il nome del pool di CA che contiene la CA subordinata.

Per ulteriori informazioni sul comando gcloud privateca subordinates enable, consulta gcloud privateca subordinates enable.

Terraform

Imposta il campo desired_state su ENABLED nella CA secondaria ed esegui terraform apply.

Passaggi successivi

Scopri come richiedere i certificati.
Scopri di più su modelli e norme di emissione.