Crea un'autorità di certificazione subordinata

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

Le CA subordinate sono responsabili dell'emissione di certificati direttamente alle entità finali, come utenti, computer e dispositivi. Le CA subordinate sono firmate in modo crittografico 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 delle entità finali emessi dalle CA subordinate.

Prima di iniziare

• Assicurati di disporre del ruolo IAM CA Service Operation Manager (roles/privateca.caManager) o Amministratore di Certificate Authority Service (roles/privateca.admin). Per informazioni, consulta Configura le policy IAM.
• Crea un pool CA.
• Seleziona la CA radice.
• Se il pool di CA contenente la CA radice di emissione ha una policy di emissione dei certificati configurata, verifica che i relativi baselineValues consentano l'emissione dei certificati CA caOptions.isCa: true, keyUsage.baseKeyUsage.certSign: true e keyUsage.baseKeyUsage.crlSign: true. In caso contrario, l'attivazione della CA subordinata non va a buon fine e viene visualizzato il messaggio di errore Fields in the CSR were modified or removed in the signed CA certificate.

Crea una CA subordinata

Le CA subordinate sono più facili da revocare e ruotare rispetto alle CA root. 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 CA ti aiuta a ottenere un migliore bilanciamento del carico delle richieste di certificati e un valore QPS totale effettivo più elevato.

Per creare una CA subordinata, segui questi passaggi:

Console

1. Vai alla pagina Certificate Authority Service nella consoleGoogle Cloud .

   Vai a Certificate Authority Service

2. Fai clic sulla scheda Gestore CA.

3. Fai clic su Crea CA.

   

Seleziona il tipo di CA

1. Fai clic su CA subordinata.
2. Fai clic su La CA principale si trova in Google Cloud.
3. Nel campo Valido per, inserisci la durata di validità del certificato CA.
4. (Facoltativo) Scegli il livello per la CA. Il livello predefinito è Enterprise. Per saperne di più, consulta Seleziona i livelli di operazione.
5. Fai clic su Regione per selezionare una località per la CA. Per saperne di più, consulta Località.
6. (Facoltativo) In Stato inizializzato, seleziona lo stato operativo in cui creare la CA.
7. (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 Profili dei certificati.
8. Fai clic su Avanti.

Configura il nome oggetto della CA

1. (Facoltativo) Nel campo Organizzazione (O), inserisci il nome della tua azienda.
2. (Facoltativo) Nel campo Unità organizzativa (UO), inserisci la divisione aziendale o l'unità aziendale.
3. (Facoltativo) Nel campo Nome paese (C), inserisci un codice paese di due lettere.
4. (Facoltativo) Nel campo Nome stato o provincia, inserisci il nome del tuo stato.
5. (Facoltativo) Nel campo Nome località, inserisci il nome della tua città.
6. Nel campo Nome comune CA (NC), inserisci il nome della CA.
7. Fai clic su Continua.

Configura dimensioni e algoritmo della chiave CA

1. Scegli l'algoritmo della chiave più adatto alle tue esigenze. Per maggiori dettagli sulle opzioni delle chiavi di firma, consulta Configura le chiavi di firma della CA.
2. Per utilizzare una chiave di firma gestita dal cliente, seleziona Chiave gestita dal cliente e fornisci la versione della chiave di crittografia di Cloud Key Management Service.
3. Fai clic su Continua.

Configura artefatti CA

1. Scegli se utilizzare un bucket Cloud Storage gestito da Google o dal cliente.
1. Per un bucket Cloud Storage gestito da Google, CA Service crea un bucket gestito da Google nella stessa località della CA.
2. Per un bucket Cloud Storage gestito dal cliente, fai clic su Sfoglia e seleziona uno dei bucket Cloud Storage esistenti.
2. Fai clic su Continua.

Aggiungi etichette

I seguenti passaggi sono facoltativi.

Se vuoi aggiungere etichette alla CA, segui questi passaggi:

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

Rivedi le impostazioni

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

gcloud

1. Crea un pool CA per la CA subordinata:

   gcloud privateca pools create SUBORDINATE_POOL_ID --location=LOCATION
   

   Sostituisci quanto segue:

   • SUBORDINATE_POOL_ID: il nome del pool CA
   • LOCATION: la località in cui vuoi creare il pool CA. Per l'elenco completo delle località, consulta Località.

   Per saperne di più sulla creazione di pool CA, consulta Crea un pool CA.

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

2. Crea una CA subordinata nel pool CA creato.

   Nota: puoi ottenere l'ID risorsa dell'emittente (ISSUER_POOL_ID) copiando l'ID dal comando create o utilizzando il comando gcloud privateca pools list.

   Assicurati che --issuer-pool specifichi l'ID del pool CA di emissione (non l'ID risorsa della CA principale). Inoltre, se nel pool di CA di emissione è configurata una policy di emissione, il relativo baselineValues deve consentire i certificati CA:

   baselineValues:
     caOptions:
       isCa: true
     keyUsage:
       baseKeyUsage:
         certSign: true
         crlSign: true
   

   Se il pool di CA emittenti limita l'emissione ai certificati di entità finale, l'attivazione della CA subordinata non riesce e viene visualizzato il messaggio di errore Fields in the CSR were modified or removed in the signed CA certificate.

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

   Sostituisci quanto segue:

   • SUBORDINATE_CA_ID: l'identificatore univoco della CA subordinata
   • SUBORDINATE_POOL_ID: il nome del pool CA
   • LOCATION: la località del pool CA
   • ISSUER_POOL_ID: il nome del pool di CA contenente la CA di emissione

   • ISSUER_LOCATION: la località del pool di CA contenente la CA di emissione

     Il flag --key-algorithm specifica l'algoritmo di crittografia che vuoi utilizzare per creare una chiave Cloud HSM gestita per la CA.

     Il flag --subject specifica il nome X.501 del soggetto del certificato.

   Per creare una CA subordinata utilizzando una chiave di firma gestita dal cliente, esegui questo comando:

   gcloud privateca subordinates create SUBORDINATE_CA_ID \
       --pool=SUBORDINATE_POOL_ID \
       --location=LOCATION \
       --issuer-pool=ISSUER_POOL_ID \
       --issuer-location=ISSUER_LOCATION \
       --kms-key-version=KMS_KEY_VERSION \
       --subject="CN=Example Server TLS CA, O=Example LLC"
   

   Sostituisci quanto segue:

   • SUBORDINATE_POOL_ID: il nome del pool CA
   • LOCATION: la località del pool CA
   • ISSUER_POOL_ID: il nome del pool di CA contenente la CA di emissione
   • ISSUER_LOCATION: la località del pool CA contenente la CA di emissione
   • KMS_KEY_VERSION: l'ID risorsa completo di una versione della chiave di crittografia Cloud KMS gestita dal cliente da utilizzare come chiave di firma

   Per maggiori dettagli sulle opzioni delle chiavi di firma e sulla preparazione di una chiave di firma gestita dal cliente, consulta Configura le chiavi di firma della CA.

   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 specificare URL di accesso personalizzati per l'accesso alle informazioni sull'autorità (AIA) e per il punto di distribuzione CRL (CDP), utilizza i flag --custom-aia-urls e --custom-cdp-urls. Se specificati, questi URL sono inclusi in tutti i certificati emessi dalla CA e sostituiscono gli URL di accesso predefiniti del bucket Cloud Storage.

   Per visualizzare un elenco completo delle impostazioni, esegui il seguente comando gcloud:

   gcloud privateca subordinates create --help
   

   Il comando restituisce esempi per creare una CA subordinata la cui emittente si trova in CA Service 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 in CA Service, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta 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 in CA Service, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta 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}")

Attiva una CA subordinata

Per attivare una CA subordinata:

Console

1. Vai alla pagina Certificate Authority Service nella consoleGoogle Cloud .

   Vai a Certificate Authority Service

2. Fai clic sulla scheda Gestore CA.

3. In Autorità di certificazione, seleziona la CA che vuoi attivare.

4. Fai clic su play_circleAbilita.

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 località del pool 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.

Java

Per attivare la CA subordinata utilizzando un certificato firmato, chiama l'RPC ActivateCertificateAuthority:

import com.google.api.core.ApiFuture;
import com.google.cloud.security.privateca.v1.ActivateCertificateAuthorityRequest;
import com.google.cloud.security.privateca.v1.CertificateAuthorityName;
import com.google.cloud.security.privateca.v1.CertificateAuthorityServiceClient;
import com.google.cloud.security.privateca.v1.SubordinateConfig;
import com.google.longrunning.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class ActivateSubordinateCa {

  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 a unique id for the CA pool.
    // subordinateCaName: The CA to be activated.
    // pemCaCertificate: The signed certificate, obtained by signing the CSR.
    String project = "your-project-id";
    String location = "ca-location";
    String poolId = "ca-pool-id";
    String subordinateCaName = "subordinate-certificate-authority-name";
    String pemCaCertificate =
        "-----BEGIN CERTIFICATE-----\n" + "sample-pem-certificate\n" + "-----END CERTIFICATE-----";

    // certificateAuthorityName: The name of the certificate authority which signed the CSR.
    // If an external CA (CA not present in Google Cloud) was used for signing,
    // then use the CA's issuerCertificateChain.
    String certificateAuthorityName = "certificate-authority-name";

    activateSubordinateCa(
        project, location, poolId, certificateAuthorityName, subordinateCaName, pemCaCertificate);
  }

  // Activate a subordinate CA.
  // *Prerequisite*: Get the CSR of the subordinate CA signed by another CA. Pass in the signed
  // certificate and (issuer CA's name or the issuer CA's Certificate chain).
  // *Post*: After activating the subordinate CA, it should be enabled before issuing certificates.
  public static void activateSubordinateCa(
      String project,
      String location,
      String poolId,
      String certificateAuthorityName,
      String subordinateCaName,
      String pemCaCertificate)
      throws ExecutionException, InterruptedException, IOException {
    // 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()) {
      // Subordinate CA parent.
      String subordinateCaParent =
          CertificateAuthorityName.of(project, location, poolId, subordinateCaName).toString();

      // Construct the "Activate CA Request".
      ActivateCertificateAuthorityRequest activateCertificateAuthorityRequest =
          ActivateCertificateAuthorityRequest.newBuilder()
              .setName(subordinateCaParent)
              // The signed certificate.
              .setPemCaCertificate(pemCaCertificate)
              .setSubordinateConfig(
                  SubordinateConfig.newBuilder()
                      // Follow one of the below methods:

                      // Method 1: If issuer CA is in Google Cloud, set the Certificate Authority
                      // Name.
                      .setCertificateAuthority(
                          CertificateAuthorityName.of(
                                  project, location, poolId, certificateAuthorityName)
                              .toString())

                      // Method 2: If issuer CA is external to Google Cloud, set the issuer's
                      // certificate chain.
                      // The certificate chain of the CA (which signed the CSR) from leaf to root.
                      // .setPemIssuerChain(
                      //     SubordinateConfigChain.newBuilder()
                      //         .addAllPemCertificates(issuerCertificateChain)
                      //         .build())

                      .build())
              .build();

      // Activate the CA.
      ApiFuture<Operation> futureCall =
          certificateAuthorityServiceClient
              .activateCertificateAuthorityCallable()
              .futureCall(activateCertificateAuthorityRequest);

      Operation response = futureCall.get();

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

      System.out.println(
          "Subordinate Certificate Authority activated successfully ! !" + subordinateCaName);
      TimeUnit.SECONDS.sleep(3);
      // The current state will be STAGED.
      // The Subordinate CA has to be ENABLED before issuing certificates.
      System.out.println(
          "Current State: "
              + certificateAuthorityServiceClient
              .getCertificateAuthority(subordinateCaParent)
              .getState());
    }
  }
}

Per attivare la CA subordinata in modo che possa emettere certificati, chiama l'RPC EnableCertificateAuthority:

import com.google.api.core.ApiFuture;
import com.google.cloud.security.privateca.v1.CertificateAuthority.State;
import com.google.cloud.security.privateca.v1.CertificateAuthorityName;
import com.google.cloud.security.privateca.v1.CertificateAuthorityServiceClient;
import com.google.cloud.security.privateca.v1.EnableCertificateAuthorityRequest;
import com.google.longrunning.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class EnableCertificateAuthority {

  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: The id of the CA pool under which the CA is present.
    // certificateAuthorityName: The name of the CA to be enabled.
    String project = "your-project-id";
    String location = "ca-location";
    String poolId = "ca-pool-id";
    String certificateAuthorityName = "certificate-authority-name";
    enableCertificateAuthority(project, location, poolId, certificateAuthorityName);
  }

  // Enable the Certificate Authority present in the given ca pool.
  // CA cannot be enabled if it has been already deleted.
  public static void enableCertificateAuthority(
      String project, String location, String poolId, String certificateAuthorityName)
      throws IOException, ExecutionException, InterruptedException {
    try (CertificateAuthorityServiceClient certificateAuthorityServiceClient =
        CertificateAuthorityServiceClient.create()) {
      // Create the Certificate Authority Name.
      CertificateAuthorityName certificateAuthorityParent =
          CertificateAuthorityName.newBuilder()
              .setProject(project)
              .setLocation(location)
              .setCaPool(poolId)
              .setCertificateAuthority(certificateAuthorityName)
              .build();

      // Create the Enable Certificate Authority Request.
      EnableCertificateAuthorityRequest enableCertificateAuthorityRequest =
          EnableCertificateAuthorityRequest.newBuilder()
              .setName(certificateAuthorityParent.toString())
              .build();

      // Enable the Certificate Authority.
      ApiFuture<Operation> futureCall =
          certificateAuthorityServiceClient
              .enableCertificateAuthorityCallable()
              .futureCall(enableCertificateAuthorityRequest);
      Operation response = futureCall.get();

      if (response.hasError()) {
        System.out.println("Error while enabling Certificate Authority !" + response.getError());
        return;
      }

      // Get the current CA state.
      State caState =
          certificateAuthorityServiceClient
              .getCertificateAuthority(certificateAuthorityParent)
              .getState();

      // Check if the CA is enabled.
      if (caState == State.ENABLED) {
        System.out.println("Enabled Certificate Authority : " + certificateAuthorityName);
      } else {
        System.out.println(
            "Cannot enable the Certificate Authority ! Current CA State: " + caState);
      }
    }
  }
}

Python

Per attivare la CA subordinata utilizzando un certificato firmato, chiama l'RPC ActivateCertificateAuthority:

import google.cloud.security.privateca_v1 as privateca_v1


def activate_subordinate_ca(
    project_id: str,
    location: str,
    ca_pool_name: str,
    subordinate_ca_name: str,
    pem_ca_certificate: str,
    ca_name: str,
) -> None:
    """
    Activate a subordinate Certificate Authority (CA).
    *Prerequisite*: Get the Certificate Signing Resource (CSR) of the subordinate CA signed by another CA. Pass in the signed
    certificate and (issuer CA's name or the issuer CA's Certificate chain).
    *Post*: After activating the subordinate CA, it should be enabled before issuing certificates.
    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.
        pem_ca_certificate: the signed certificate, obtained by signing the CSR.
        subordinate_ca_name: the CA to be activated.
        ca_name: The name of the certificate authority which signed the CSR.
            If an external CA (CA not present in Google Cloud) was used for signing,
            then use the CA's issuerCertificateChain.
    """

    ca_service_client = privateca_v1.CertificateAuthorityServiceClient()

    subordinate_ca_path = ca_service_client.certificate_authority_path(
        project_id, location, ca_pool_name, subordinate_ca_name
    )
    ca_path = ca_service_client.certificate_authority_path(
        project_id, location, ca_pool_name, ca_name
    )

    # Set CA subordinate config.
    subordinate_config = privateca_v1.SubordinateConfig(
        # Follow one of the below methods:
        # Method 1: If issuer CA is in Google Cloud, set the Certificate Authority Name.
        certificate_authority=ca_path,
        # Method 2: If issuer CA is external to Google Cloud, set the issuer's certificate chain.
        # The certificate chain of the CA (which signed the CSR) from leaf to root.
        # pem_issuer_chain=privateca_v1.SubordinateConfig.SubordinateConfigChain(
        #     pem_certificates=issuer_certificate_chain,
        # )
    )

    # Construct the "Activate CA Request".
    request = privateca_v1.ActivateCertificateAuthorityRequest(
        name=subordinate_ca_path,
        # The signed certificate.
        pem_ca_certificate=pem_ca_certificate,
        subordinate_config=subordinate_config,
    )

    # Activate the CA
    operation = ca_service_client.activate_certificate_authority(request=request)
    result = operation.result()

    print("Operation result:", result)

    # The current state will be STAGED.
    # The Subordinate CA has to be ENABLED before issuing certificates.
    print(
        f"Current state: {ca_service_client.get_certificate_authority(name=subordinate_ca_path).state}"
    )

Per attivare la CA subordinata in modo che possa emettere certificati, chiama l'RPC EnableCertificateAuthority:

import google.cloud.security.privateca_v1 as privateca_v1


def enable_certificate_authority(
    project_id: str, location: str, ca_pool_name: str, ca_name: str
) -> None:
    """
    Enable the Certificate Authority present in the given ca pool.
    CA cannot be enabled if it has been already deleted.

    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: the name of the CA pool under which the CA is present.
        ca_name: the name of the CA to be enabled.
    """

    caServiceClient = privateca_v1.CertificateAuthorityServiceClient()
    ca_path = caServiceClient.certificate_authority_path(
        project_id, location, ca_pool_name, ca_name
    )

    # Create the Enable Certificate Authority Request.
    request = privateca_v1.EnableCertificateAuthorityRequest(
        name=ca_path,
    )

    # Enable the Certificate Authority.
    operation = caServiceClient.enable_certificate_authority(request=request)
    operation.result()

    # Get the current CA state.
    ca_state = caServiceClient.get_certificate_authority(name=ca_path).state

    # Check if the CA is enabled.
    if ca_state == privateca_v1.CertificateAuthority.State.ENABLED:
        print("Enabled Certificate Authority:", ca_name)
    else:
        print("Cannot enable the Certificate Authority ! Current CA State:", ca_state)

Nota: CA Service non controlla lo stato di revoca della CA principale prima di abilitare una CA subordinata che si collega a questa. L'unica eccezione a questa policy è quando hai creato la CA principale utilizzando CA Service. In questo scenario, CA Service controlla lo stato di revoca della CA root ogni giorno. Se la CA principale viene revocata, CA Service aggiorna la metrica privateca.googleapis.com/ca/cert_revoked sulla CA subordinata.

Passaggi successivi

• Scopri come richiedere i certificati.
• Scopri come inviare una richiesta di certificato utilizzando una CSR.
• Scopri di più sui modelli e sulle policy di emissione.