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 a entità finali come utenti, computer e dispositivi. Le CA subordinate sono firmate crittograficamente da una CA principale, che spesso è la CA radice. Di conseguenza, i sistemi che considerano attendibile la CA radice considerano automaticamente attendibili le CA subordinate e i certificati dell'entità finale 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, vedi Configurare i criteri IAM.
Crea un pool di CA.
Seleziona la CA radice.

Crea una CA subordinata

Le CA subordinate sono più facili da revocare e ruotare rispetto alle CA radice. Se hai più scenari di emissione 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 ottenere un migliore bilanciamento del carico delle richieste di certificato e un QPS effettivo totale più elevato.

Per creare una CA subordinata:

Console

Vai alla pagina Certificate Authority Service nella consoleGoogle 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 cui vuoi che il certificato CA sia valido.
(Facoltativo) Scegli il livello per la CA. Il livello predefinito è Enterprise. Per saperne di più, 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 trovarsi la CA al momento della creazione.
(Facoltativo) In Configura uno scenario di emissione, fai clic su Profilo certificato e seleziona dall'elenco il profilo certificato più adatto alle tue esigenze. Per saperne di più, consulta la sezione Profili certificato.
Fai clic su Avanti.

Configura il nome soggetto della CA

Nel campo Organizzazione (O), inserisci il nome della tua azienda.
(Facoltativo) Nel campo Unità organizzativa, inserisci la divisione aziendale o la business unit.
(Facoltativo) Nel campo Nome paese (C), 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 (NC), inserisci il nome della CA.
Fai clic su Continua.

Configura dimensioni e algoritmo della chiave CA

Scegli l'algoritmo chiave più adatto alle tue esigenze. Per informazioni su come decidere l'algoritmo chiave più adatto, vedi Scegliere un algoritmo chiave.
Fai clic su Continua.

Configura artefatti CA

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

Per un bucket Cloud Storage gestito da Google, CA Service crea un bucket gestito da Google nella stessa località della CA.
Per un bucket Cloud Storage gestito dal cliente, fai clic su Sfoglia e seleziona uno dei bucket Cloud Storage esistenti.

Fai clic su Continua.

Aggiungere etichette

I seguenti passaggi 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. A questo punto, aggiungi la chiave e il valore dell'etichetta come indicato nei passaggi 2 e 3.
Fai clic su Continua.

Rivedi le impostazioni

Esamina attentamente tutte le impostazioni, poi fai clic su Fine per creare l'autorità di certificazione.

gcloud

Crea un pool di CA per la CA subordinata:
```
gcloud privateca pools create SUBORDINATE_POOL_ID --location=LOCATION
```
Sostituisci quanto segue:
- SUBORDINATE_POOL_ID: il nome del pool di CA.
- LOCATION: la località in cui vuoi creare il pool di CA. Per l'elenco completo delle località, consulta Località.
Per saperne di più sulla creazione di pool di CA, consulta Creare un pool di CA.

Per saperne di più sul comando gcloud privateca pools create, consulta gcloud privateca pools create.

Crea una CA subordinata nel pool di CA creato.

gcloud privateca subordinates create SUBORDINATE_CA_ID \
    --pool=SUBORDINATE_POOL_ID \
    --location=LOCATION \
    --issuer-pool=POOL_ID \
    --issuer-location=ISSUER_LOCATION \
    --key-algorithm="ec-p256-sha256" \
    --subject="CN=Example Server TLS CA, O=Example LLC"

Quando viene creata la CA subordinata, viene restituita la seguente istruzione.

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 questo 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 eseguire l'autenticazione al servizio CA, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 eseguire l'autenticazione al servizio CA, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 consoleGoogle 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 che si apre, 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 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 subordinata appena creata, esegui questo comando:

gcloud privateca subordinates enable SUBORDINATE_CA_ID \
--pool=SUBORDINATE_POOL_ID \
--location=LOCATION

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.
LOCATION: la posizione del pool di CA. Per l'elenco completo delle località, consulta Località.

Per saperne di più sul comando gcloud privateca subordinates enable, consulta gcloud privateca subordinates enable.

Terraform

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

Passaggi successivi

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