Créer une autorité de certification subordonnée

Cette page explique comment créer des autorités de certification (CA) subordonnées dans un pool d'autorités de certification.

Les autorités de certification subordonnées sont chargées d'émettre des certificats directement auprès des entités finales, telles que les utilisateurs, les ordinateurs et les appareils. Elles sont signées de manière cryptographique par une autorité de certification parente, qui est souvent l'autorité de certification racine. Par conséquent, les systèmes qui font confiance à l'autorité de certification racine font automatiquement confiance aux autorités de certification subordonnées et aux certificats d'entité finale qu'elles émettent.

Avant de commencer

• Assurez-vous de disposer du rôle IAM "Gestionnaire d'opérations du service d'autorités de certification" (roles/privateca.caManager) ou "Administrateur du service d'autorités de certification" (roles/privateca.admin). Pour en savoir plus, consultez Configurer des stratégies IAM.
• Créez un pool d'autorités de certification.
• Sélectionnez votre autorité de certification racine.

Créer une autorité de certification subordonnée

Les autorités de certification subordonnées sont plus faciles à révoquer et à alterner que les autorités de certification racines. Si vous disposez de plusieurs scénarios d'émission de certificat, vous pouvez créer une autorité de certification subordonnée pour chacun d'entre eux. L'ajout de plusieurs autorités de certification subordonnées dans un pool d'autorités de certification vous permet d'améliorer l'équilibrage de charge des requêtes de certificat et d'obtenir un QPS effectif total plus élevé.

Pour créer une autorité de certification subordonnée, procédez comme suit :

Console

1. Accédez à la page Certificate Authority Service (Service d'autorité de certification) dans la Google Cloud console.

   Accéder à Certificate Authority Service

2. Cliquez sur l'onglet CA manager (Gestionnaire d'autorités de certification).

3. Cliquez sur Create CA (Créer une autorité de certification).

   

Sélectionner le type d'autorité de certification

1. Cliquez sur Subordinate CA (Autorité de certification subordonnée).
2. Cliquez sur Root CA is in Google Cloud (L'autorité de certification racine se trouve dans Google Cloud).
3. Dans le champ Valid for (Valide pour), saisissez la durée de validité du certificat de l'autorité de certification.
4. Facultatif : Choisissez le niveau de l'autorité de certification. Le niveau par défaut est Enterprise. Pour en savoir plus, consultez Sélectionner les niveaux d'opération.
5. Cliquez sur Region (Région) pour sélectionner un emplacement pour l'autorité de certification. Pour en savoir plus, consultez Emplacements.
6. Facultatif : Sous Initialized state (État initialisé), sélectionnez l'état opérationnel dans lequel créer l'autorité de certification.
7. Facultatif : Sous Set up an issuance scenario (Configurer un scénario d’émission), cliquez sur Certificate profile (Profil de certificat), puis sélectionnez dans la liste le profil de certificat qui répond le mieux à vos exigences. Pour en savoir plus, consultez Profils de certificat.
8. Cliquez sur Next (Suivant).

Configurer le nom d'objet de l'autorité de certification

1. Facultatif : Dans le champ Organization (O) (Organisation), saisissez le nom de votre entreprise.
2. Facultatif : Dans le champ Organization unit (OU) (Unité organisationnelle), saisissez la subdivision de l'entreprise ou l'unité commerciale.
3. Facultatif : Dans le champ Country name (C) (Nom du pays), saisissez un code pays à deux lettres.
4. Facultatif : Dans le champ State or province name (Nom de l'État ou de la province), saisissez le nom de votre État.
5. Facultatif : Dans le champ Locality name (Nom de la localité), saisissez le nom de votre ville.
6. Dans le champ CA common name (CN) (Nom courant de l'autorité de certification), saisissez le nom de l'autorité de certification.
7. Cliquez sur Continue (Continuer).

Configurer l'algorithme et la taille de clé de l'autorité de certification

1. Choisissez l'algorithme de clé qui répond le mieux à vos besoins. Pour en savoir plus sur les options de clé de signature, consultez Configurer des clés de signature d'autorité de certification.
2. Pour utiliser une clé de signature gérée par le client, sélectionnez Customer-managed key (Clé gérée par le client), puis indiquez la version de la clé de chiffrement Cloud Key Management Service.
3. Cliquez sur Continue (Continuer).

Configurer les artefacts d'autorité de certification

1. Indiquez si vous souhaitez utiliser un bucket Cloud Storage géré par Google ou par le client.
1. Pour un bucket Cloud Storage géré par Google, CA Service crée un bucket géré par Google au même emplacement que l'autorité de certification.
2. Pour un bucket Cloud Storage géré par le client, cliquez sur "Browse" (Parcourir), puis sélectionnez l'un des buckets Cloud Storage existants.
2. Cliquez sur Continue (Continuer).

Ajouter des libellés

Les étapes suivantes sont facultatives.

Pour ajouter des libellés à l'autorité de certification, procédez comme suit :

1. Cliquez sur Add item (Ajouter un élément).
2. Dans le champ Key 1 (Clé 1), saisissez la clé du libellé.
3. Dans le champ Value 1 (Valeur 1), saisissez la valeur du libellé.
4. Si vous souhaitez ajouter un autre libellé, cliquez sur Add item (Ajouter un élément). Ajoutez ensuite la clé et la valeur du libellé comme indiqué aux étapes 2 et 3.
5. Cliquez sur Continue (Continuer).

Vérifier les paramètres

Examinez attentivement tous les paramètres, puis cliquez sur Done (OK) pour créer l'autorité de certification.

gcloud

1. Créez un pool d'autorités de certification pour l'autorité de certification subordonnée :

   gcloud privateca pools create SUBORDINATE_POOL_ID --location=LOCATION
   

   Remplacez les éléments suivants :

   • SUBORDINATE_POOL_ID : nom du pool d'autorités de certification
   • LOCATION : emplacement dans lequel vous souhaitez créer le pool d'autorités de certification. Pour obtenir la liste complète des emplacements, consultez Emplacements.

   Pour en savoir plus sur la création de pools d'autorités de certification, consultez Créer un pool d'autorités de certification.

   Pour en savoir plus sur la commande gcloud privateca pools create, consultez gcloud privateca pools create.

2. Créez une autorité de certification subordonnée dans le pool d'autorités de certification créé.

   Remarque : Vous pouvez obtenir l'ID de ressource de l'émetteur (ISSUER_POOL_ID) en copiant l'ID à partir de la commande de création ou en utilisant la commande gcloud privateca pools list.

   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"
   

   Remplacez les éléments suivants :

   • SUBORDINATE_CA_ID : identifiant unique de l' autorité de certification subordonnée
   • SUBORDINATE_POOL_ID : nom du pool d'autorités de certification
   • LOCATION : emplacement du pool d'autorités de certification
   • ISSUER_POOL_ID : nom du pool d'autorités de certification contenant l'autorité de certification émettrice

   • ISSUER_LOCATION : emplacement du pool d'autorités de certification contenant l'autorité de certification émettrice

     L'option --key-algorithm spécifie l'algorithme cryptographique que vous souhaitez utiliser pour créer une clé Cloud HSM gérée pour l'autorité de certification.

     L'option --subject spécifie le nom X.501 de l'objet du certificat.

   Pour créer une autorité de certification subordonnée à l'aide d'une clé de signature gérée par le client, exécutez la commande suivante :

   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"
   

   Remplacez les éléments suivants :

   • SUBORDINATE_POOL_ID : nom du pool d'autorités de certification
   • LOCATION : emplacement du pool d'autorités de certification
   • ISSUER_POOL_ID : nom du pool d'autorités de certification contenant l'autorité de certification émettrice
   • ISSUER_LOCATION : emplacement du pool d'autorités de certification contenant l'autorité de certification émettrice
   • KMS_KEY_VERSION : ID de ressource complet d'une version de clé de chiffrement Cloud KMS gérée par le client à utiliser comme clé de signature

   Pour en savoir plus sur les options de clé de signature et sur la préparation d'une clé de signature gérée par le client, consultez Configurer des clés de signature d'autorité de certification.

   L'instruction suivante est renvoyée lorsque l'autorité de certification subordonnée est créée.

   Created Certificate Authority [projects/my-project-pki/locations/us-west1/caPools/SUBORDINATE_POOL_ID/certificateAuthorities/SUBORDINATE_CA_ID].
   

   Pour spécifier des URL d'accès personnalisées pour l'accès aux informations de l'autorité (AIA) et au point de distribution de la liste de révocation des certificats (CRL), utilisez les options --custom-aia-urls et --custom-cdp-urls. Si elles sont spécifiées, ces URL sont incluses dans tous les certificats émis par l'autorité de certification et remplacent les URL d'accès par défaut au bucket Cloud Storage.

   Pour afficher une liste exhaustive des paramètres, exécutez la commande gcloud suivante :

   gcloud privateca subordinates create --help
   

   La commande renvoie des exemples permettant de créer une autorité de certification subordonnée dont l'émetteur se trouve dans CA Service ou ailleurs.

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

Pour vous authentifier auprès de CA Service, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour vous authentifier auprès de CA Service, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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}")

Activer une autorité de certification subordonnée

Pour activer une autorité de certification subordonnée, procédez comme suit :

Console

1. Accédez à la page Certificate Authority Service (Service d'autorité de certification) dans la Google Cloud console.

   Accéder à Certificate Authority Service

2. Cliquez sur l'onglet CA manager (Gestionnaire d'autorités de certification).

3. Sous Certificate authorities (Autorités de certification), sélectionnez l'autorité de certification que vous souhaitez activer.

4. Cliquez sur play_circleEnable (Activer).

gcloud

Pour activer une autorité de certification subordonnée nouvellement créée, exécutez la commande suivante :

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

Remplacez les éléments suivants :

• SUBORDINATE_CA_ID : identifiant unique de l' autorité de certification subordonnée
• SUBORDINATE_POOL_ID : nom du pool d'autorités de certification qui contient l'autorité de certification subordonnée
• LOCATION: emplacement du pool d'autorités de certification. Pour obtenir la liste complète des emplacements, consultez Emplacements.

Pour en savoir plus sur la gcloud privateca subordinates enable commande, consultez gcloud privateca subordinates enable.

Terraform

Définissez le champ desired_state sur ENABLED pour l'autorité de certification subordonnée, puis exécutez terraform apply.

Java

Pour activer l'autorité de certification subordonnée à l'aide d'un certificat signé, appelez le 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());
    }
  }
}

Pour activer l'autorité de certification subordonnée afin qu'elle puisse émettre des certificats, appelez le 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

Pour activer l'autorité de certification subordonnée à l'aide d'un certificat signé, appelez le 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}"
    )

Pour activer l'autorité de certification subordonnée afin qu'elle puisse émettre des certificats, appelez le 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)

Remarque : CA Service ne vérifie pas l'état de révocation de l'autorité de certification racine avant d'activer une autorité de certification subordonnée qui y est associée. La seule exception à cette règle se produit lorsque vous avez créé l'autorité de certification racine à l'aide de CA Service. Dans ce scénario, CA Service vérifie quotidiennement l'état de révocation de l'autorité de certification racine. Si l'autorité de certification racine est révoquée, CA Service met à jour la privateca.googleapis.com/ca/cert_revoked métrique sur l' autorité de certification subordonnée.

Étape suivante

• Découvrez comment demander des certificats.
• Découvrez comment envoyer une demande de certificat à l' aide d'une CSR.
• Découvrez les modèles et les stratégies d'émission politiques.