Créer une autorité de certification racine

Cette page explique comment créer une autorité de certification racine (AC) dans un pool d'autorités de certification.

Une autorité de certification racine se trouve au sommet de la hiérarchie d'une infrastructure à clé publique (PKI) et est chargée de former l'ancre de confiance de la PKI. Pour participer correctement à une PKI et utiliser les certificats, un appareil, un logiciel ou un composant doit faire confiance à la PKI. Pour ce faire, configurez l'appareil, le logiciel ou le composant pour qu'il fasse confiance à l'autorité de certification racine. Par conséquent, tous les certificats émis par l'autorité de certification racine sont approuvés.

Avant de commencer

Créer une autorité de certification racine

Une autorité de certification racine dispose d'un certificat autosigné que vous devez distribuer aux magasins de confiance de vos clients. Le certificat de l'autorité de certification racine se trouve en haut de la chaîne de certificats. Aucune autre autorité de certification ne peut révoquer le certificat de l'autorité de certification. La liste de révocation de l'autorité de certification racine ne s'applique qu'aux autres certificats qu'elle a émis, mais pas à elle-même.

Console

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

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

    Accéder à Certificate Authority Service

  2. Cliquez sur l'onglet Gestionnaire d'autorités de certification.

  3. Cliquez sur Créer une autorité de certification.

Sélectionner le type d'autorité de certification

Pour configurer les paramètres permanents de l'autorité de certification, tels que le niveau, l'emplacement, la durée de vie et l'état opérationnel lors de la création, procédez comme suit:

  1. Sélectionnez Autorité de certification racine.
  2. Dans le champ Valide pour, saisissez la durée pendant laquelle vous souhaitez que les certificats émis par le certificat d'autorité de certification soient valides.
  3. Facultatif: sélectionnez un niveau pour l'autorité de certification.
  4. Cliquez sur Région, puis dans la liste, sélectionnez l'emplacement où vous souhaitez créer l'autorité de certification. Nous vous recommandons de créer l'autorité de certification à proximité géographique des clients de votre application. Pour en savoir plus, consultez Choisir le meilleur emplacement.

  5. Facultatif: sélectionnez l'état opérationnel de l'autorité de certification à créer.

    Choisissez l'état de fonctionnement de l'autorité de certification à créer.

  6. Facultatif: cliquez sur Profil de certificat. Dans la liste, sélectionnez le profil de certificat correspondant au type de certificats que vous souhaitez que l'autorité de certification émette.

  7. Cliquez sur Suivant.

Configurer le nom d'objet de l'autorité de certification
  1. Dans le champ Organisation (O), saisissez le nom de votre entreprise.
  2. Facultatif: Dans le champ Unité organisationnelle (UO), saisissez la subdivision de l'entreprise ou l'unité commerciale.
  3. Facultatif: Dans le champ Nom du pays, saisissez un code pays à deux lettres.
  4. Facultatif: Dans le champ Nom de l'État ou de la province, saisissez le nom de votre État.
  5. Facultatif: Dans le champ Nom de la localité, saisissez le nom de votre ville.
  6. Dans le champ Nom courant de l'autorité de certification (CN), saisissez le nom de l'autorité de certification.
  7. Dans le champ ID du pool, saisissez le nom du pool d'autorités de certification. Vous ne pouvez pas modifier le pool d'autorités de certification une fois l'autorité de certification créée.
  8. Cliquez sur Suivant.
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 savoir comment choisir l'algorithme de clé approprié, consultez la section Choisir un algorithme de clé.
  2. Cliquez sur Suivant.
Configurer les artefacts des autorités de certification

Les étapes suivantes sont facultatives. Si vous ignorez ces étapes, les paramètres par défaut s'appliquent.

  1. Indiquez si vous souhaitez utiliser un bucket Cloud Storage géré par Google ou géré par vous-même.

    2. Si vous ne sélectionnez pas de bucket Cloud Storage autogéré, CA Service crée un bucket géré par Google au même emplacement que l'autorité de certification.

  2. Indiquez si vous souhaitez désactiver la publication des listes de révocation de certificats (LRC) et des certificats d'autorité de certification dans le bucket Cloud Storage.

    3. La publication de la liste de révocation de certificats et du certificat de l'autorité de certification dans un bucket Cloud Storage est activée par défaut. Pour désactiver ces paramètres, cliquez sur les boutons d'activation/de désactivation.

  3. Cliquez sur Suivant.
Ajouter des libellés

Les étapes suivantes sont facultatives.

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

  1. Cliquez sur Ajouter un élément.
  2. Dans le champ Clé 1, saisissez la clé de libellé.
  3. Dans le champ Valeur 1, saisissez la valeur de l'étiquette.
  4. Si vous souhaitez ajouter un autre libellé, cliquez sur Ajouter un élément. Ajoutez ensuite la clé et la valeur du libellé, comme indiqué aux étapes 2 et 3.
  5. Cliquez sur Suivant.
Vérifier les paramètres

Vérifiez attentivement tous les paramètres, puis cliquez sur Créer pour créer l'autorité de certification.

gcloud

  1. Pour créer un pool d'autorités de certification, exécutez la commande suivante:

    gcloud privateca pools create POOL_ID --location=LOCATION

    Remplacez les éléments suivants :

    • 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 la section Emplacements.

    Pour en savoir plus, consultez Créer un pool d'autorités de certification.

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

  2. Créez une autorité de certification racine dans le pool d'autorités de certification que vous avez créé.

    gcloud privateca roots create ROOT_CA_ID \
    --location=LOCATION \
    --pool=POOL_ID \
    --key-algorithm=KEY_ALGORITHM \
    --subject="CN=my-ca, O=Test LLC"

    Remplacez les éléments suivants :

    • ROOT_CA_ID: nom de l'autorité de certification.
    • LOCATION: emplacement du pool d'autorités de certification.
    • POOL_ID: nom du pool d'autorités de certification.
    • KEY_ALGORITHM: algorithme à utiliser pour créer une clé Cloud KMS. Cette option est facultative. Si vous n'incluez pas cet indicateur, l'algorithme de clé est défini par défaut sur rsa-pkcs1-4096-sha256. Pour en savoir plus, consultez l'option --key-algorithm.

    Par défaut, l'autorité de certification est créée à l'état STAGED. Pour activer une autorité de certification par défaut, incluez l'indicateur --auto-enable.

    Si vous souhaitez utiliser un bucket Cloud Storage géré par le client pour publier des certificats d'autorité de certification et des listes de révocation de certificats, ajoutez --bucket bucket-name à la commande. Remplacez bucket-name par le nom du bucket Cloud Storage.

    Pour afficher la liste complète des paramètres, exécutez la commande suivante:

    gcloud privateca roots create --help

Terraform

Pour créer une autorité de certification racine à l'aide d'une clé de chiffrement appartenant à Google et gérée par Google , utilisez l'exemple de configuration suivant:

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

Pour créer une autorité de certification racine à l'aide d'une clé autogérée, utilisez l'exemple de configuration suivant:

resource "google_project_service_identity" "privateca_sa" {
  provider = google-beta
  service  = "privateca.googleapis.com"
}

resource "google_kms_crypto_key_iam_binding" "privateca_sa_keyuser_signerverifier" {
  crypto_key_id = "projects/keys-project/locations/us-central1/keyRings/key-ring/cryptoKeys/crypto-key"
  role          = "roles/cloudkms.signerVerifier"

  members = [
    "serviceAccount:${google_project_service_identity.privateca_sa.email}",
  ]
}

resource "google_kms_crypto_key_iam_binding" "privateca_sa_keyuser_viewer" {
  crypto_key_id = "projects/keys-project/locations/us-central1/keyRings/key-ring/cryptoKeys/crypto-key"
  role          = "roles/viewer"
  members = [
    "serviceAccount:${google_project_service_identity.privateca_sa.email}",
  ]
}

resource "google_privateca_certificate_authority" "default" {
  // This example assumes this pool already exists.
  // Pools cannot be deleted in normal test circumstances, so we depend on static pools
  pool                     = "ca-pool"
  certificate_authority_id = "my-certificate-authority"
  location                 = "us-central1"
  deletion_protection      = false # set to true to prevent destruction of the resource
  key_spec {
    cloud_kms_key_version = "projects/keys-project/locations/us-central1/keyRings/key-ring/cryptoKeys/crypto-key/cryptoKeyVersions/1"
  }

  config {
    subject_config {
      subject {
        organization = "Example, Org."
        common_name  = "Example Authority"
      }
    }
    x509_config {
      ca_options {
        # is_ca *MUST* be true for certificate authorities
        is_ca                  = true
        max_issuer_path_length = 10
      }
      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 {
          server_auth = false
        }
      }
    }
  }

  depends_on = [
    google_kms_crypto_key_iam_binding.privateca_sa_keyuser_signerverifier,
    google_kms_crypto_key_iam_binding.privateca_sa_keyuser_viewer,
  ]
}

Go

Pour vous authentifier auprès du service d'autorité de certification, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

import (
	"context"
	"fmt"
	"io"

	privateca "cloud.google.com/go/security/privateca/apiv1"
	"cloud.google.com/go/security/privateca/apiv1/privatecapb"
	"google.golang.org/protobuf/types/known/durationpb"
)

// Create Certificate Authority which is the root CA in the given CA Pool. This CA will be
// responsible for signing certificates within this pool.
func createCa(
	w io.Writer,
	projectId string,
	location string,
	caPoolId string,
	caId string,
	caCommonName string,
	org string,
	caDuration int64) error {
	// projectId := "your_project_id"
	// location := "us-central1"		// For a list of locations, see: https://cloud.google.com/certificate-authority-service/docs/locations.
	// caPoolId := "ca-pool-id"			// The CA Pool id under which the CA should be created.
	// caId := "ca-id"					// A unique id/name for the ca.
	// caCommonName := "ca-name"		// A common name for your certificate authority.
	// org := "ca-org"					// The name of your company for your certificate authority.
	// ca_duration := int64(31536000)	// The validity of the certificate authority in seconds.

	ctx := context.Background()
	caClient, err := privateca.NewCertificateAuthorityClient(ctx)
	if err != nil {
		return fmt.Errorf("NewCertificateAuthorityClient creation failed: %w", err)
	}
	defer caClient.Close()

	// Set the types of Algorithm used to create a cloud KMS key.
	keySpec := &privatecapb.CertificateAuthority_KeyVersionSpec{
		KeyVersion: &privatecapb.CertificateAuthority_KeyVersionSpec_Algorithm{
			Algorithm: privatecapb.CertificateAuthority_RSA_PKCS1_2048_SHA256,
		},
	}

	// Set CA subject config.
	subjectConfig := &privatecapb.CertificateConfig_SubjectConfig{
		Subject: &privatecapb.Subject{
			CommonName:   caCommonName,
			Organization: org,
		},
	}

	// Set the key usage options for X.509 fields.
	isCa := true
	x509Parameters := &privatecapb.X509Parameters{
		KeyUsage: &privatecapb.KeyUsage{
			BaseKeyUsage: &privatecapb.KeyUsage_KeyUsageOptions{
				CrlSign:  true,
				CertSign: true,
			},
		},
		CaOptions: &privatecapb.X509Parameters_CaOptions{
			IsCa: &isCa,
		},
	}

	// Set certificate authority settings.
	// Type: SELF_SIGNED denotes that this CA is a root CA.
	ca := &privatecapb.CertificateAuthority{
		Type:    privatecapb.CertificateAuthority_SELF_SIGNED,
		KeySpec: keySpec,
		Config: &privatecapb.CertificateConfig{
			SubjectConfig: subjectConfig,
			X509Config:    x509Parameters,
		},
		Lifetime: &durationpb.Duration{
			Seconds: caDuration,
		},
	}

	fullCaPoolName := fmt.Sprintf("projects/%s/locations/%s/caPools/%s", projectId, location, caPoolId)

	// Create the CreateCertificateAuthorityRequest.
	// See https://pkg.go.dev/cloud.google.com/go/security/privateca/apiv1/privatecapb#CreateCertificateAuthorityRequest.
	req := &privatecapb.CreateCertificateAuthorityRequest{
		Parent:                 fullCaPoolName,
		CertificateAuthorityId: caId,
		CertificateAuthority:   ca,
	}

	op, err := caClient.CreateCertificateAuthority(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateCertificateAuthority failed: %w", err)
	}

	if _, err = op.Wait(ctx); err != nil {
		return fmt.Errorf("CreateCertificateAuthority failed during wait: %w", err)
	}

	fmt.Fprintf(w, "CA %s created", caId)

	return nil
}

Java

Pour vous authentifier auprès du service d'autorité de certification, configurez les 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.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 CreateCertificateAuthority {

  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.
    // certificateAuthorityName: Unique name for the CA.
    String project = "your-project-id";
    String location = "ca-location";
    String poolId = "ca-pool-id";
    String certificateAuthorityName = "certificate-authority-name";
    createCertificateAuthority(project, location, poolId, certificateAuthorityName);
  }

  // Create Certificate Authority which is the root CA in the given CA Pool.
  public static void createCertificateAuthority(
      String project, String location, String poolId, String certificateAuthorityName)
      throws InterruptedException, ExecutionException, 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()) {

      String commonName = "common-name";
      String orgName = "org-name";
      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())
              .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 certificateAuthority =
          CertificateAuthority.newBuilder()
              // CertificateAuthority.Type.SELF_SIGNED denotes that this CA is a root CA.
              .setType(CertificateAuthority.Type.SELF_SIGNED)
              .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 certificateAuthorityRequest =
          CreateCertificateAuthorityRequest.newBuilder()
              .setParent(CaPoolName.of(project, location, poolId).toString())
              .setCertificateAuthorityId(certificateAuthorityName)
              .setCertificateAuthority(certificateAuthority)
              .build();

      // Create Certificate Authority.
      ApiFuture<Operation> futureCall =
          certificateAuthorityServiceClient
              .createCertificateAuthorityCallable()
              .futureCall(certificateAuthorityRequest);
      Operation response = futureCall.get();

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

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

Python

Pour vous authentifier auprès du service d'autorité de certification, configurez les 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_certificate_authority(
    project_id: str,
    location: str,
    ca_pool_name: str,
    ca_name: str,
    common_name: str,
    organization: str,
    ca_duration: int,
) -> None:
    """
    Create Certificate Authority which is the root CA in the given CA Pool. This CA will be
    responsible for signing certificates within this 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.
        ca_name: unique name for the CA.
        common_name: a title for your certificate authority.
        organization: the name of your company for your certificate authority.
        ca_duration: the validity of the certificate authority in seconds.
    """

    caServiceClient = privateca_v1.CertificateAuthorityServiceClient()

    # Set the types of Algorithm used to create a cloud KMS key.
    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 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(
        # CertificateAuthority.Type.SELF_SIGNED denotes that this CA is a root CA.
        type_=privateca_v1.CertificateAuthority.Type.SELF_SIGNED,
        key_spec=key_version_spec,
        config=privateca_v1.CertificateConfig(
            subject_config=subject_config,
            x509_config=x509_parameters,
        ),
        lifetime=duration_pb2.Duration(seconds=ca_duration),
    )

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

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

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

    print("Operation result:", result)

API REST

  1. Créez une autorité de certification racine.

    Méthode HTTP et URL : 

    POST https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificateAuthorities?certificate_authority_id=ROOT_CA_ID

    Corps JSON de la requête :

    {
"type": "SELF_SIGNED",
"lifetime": {
  "seconds": 315576000,
  "nanos": 0
},
"config": {
  "subject_config": {
    "subject": {
      "organization": "ORGANIZATION_NAME",
      "common_name": "COMMON_NAME"
    }
  },
  "x509_config":{
    "ca_options":{
      "is_ca":true
    },
    "key_usage":{
      "base_key_usage":{
        "cert_sign":true,
        "crl_sign":true
      }
    }
  }
},
"key_spec":{
  "algorithm":"RSA_PKCS1_4096_SHA256"
}
}

    Pour envoyer votre requête, développez l'une des options suivantes :

    Vous devriez recevoir une réponse JSON de ce type :

    {
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID",
  "metadata": {...},
  "done": false
}

  2. Interrogez l'opération jusqu'à ce qu'elle soit terminée.

    Méthode HTTP et URL : 

    GET https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID

    Pour envoyer votre requête, développez l'une des options suivantes :

    Vous devriez recevoir une réponse JSON de ce type :

    {
 "name": "projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID",
 "metadata": {...},
 "done": true,
 "response": {
   "@type": "type.googleapis.com/google.cloud.security.privateca.v1.CertificateAuthority",
   "name": "...",
 }
}

Après avoir vérifié que l'autorité de certification fonctionne comme prévu, vous pouvez l'activer pour qu'elle commence à émettre des certificats équilibrés en charge pour le pool d'autorités de certification.

Activer une autorité de certification racine

gcloud

Pour activer une autorité de certification racine, exécutez la commande gcloud suivante:

gcloud privateca roots enable ROOT_CA_ID --location=LOCATION --pool=POOL_ID

Remplacez les éléments suivants :

  • ROOT_CA_ID: nom de l'autorité de certification.
  • LOCATION: emplacement du pool d'autorités de certification. Pour obtenir la liste complète des emplacements, consultez la section Emplacements.
  • POOL_ID: nom du pool d'autorités de certification.

Terraform

Si vous utilisez Terraform pour créer une autorité de certification racine, elle est activée à la création. Pour créer une autorité de certification racine dans l'état STAGED, définissez le champ desired_state sur STAGED lorsque vous créez l'autorité de certification.

Vous pouvez définir le champ desired_state sur ENABLED ou DISABLED après la création de l'autorité de certification.

Go

Pour vous authentifier auprès du service d'autorité de certification, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

import (
	"context"
	"fmt"
	"io"

	privateca "cloud.google.com/go/security/privateca/apiv1"
	"cloud.google.com/go/security/privateca/apiv1/privatecapb"
)

// Enable the Certificate Authority present in the given ca pool.
// CA cannot be enabled if it has been already deleted.
func enableCa(w io.Writer, projectId string, location string, caPoolId string, caId string) error {
	// projectId := "your_project_id"
	// location := "us-central1"	// For a list of locations, see: https://cloud.google.com/certificate-authority-service/docs/locations.
	// caPoolId := "ca-pool-id"		// The id of the CA pool under which the CA is present.
	// caId := "ca-id"				// The id of the CA to be enabled.

	ctx := context.Background()
	caClient, err := privateca.NewCertificateAuthorityClient(ctx)
	if err != nil {
		return fmt.Errorf("NewCertificateAuthorityClient creation failed: %w", err)
	}
	defer caClient.Close()

	fullCaName := fmt.Sprintf("projects/%s/locations/%s/caPools/%s/certificateAuthorities/%s",
		projectId, location, caPoolId, caId)

	// Create the EnableCertificateAuthorityRequest.
	// See https://pkg.go.dev/cloud.google.com/go/security/privateca/apiv1/privatecapb#EnableCertificateAuthorityRequest.
	req := &privatecapb.EnableCertificateAuthorityRequest{Name: fullCaName}

	op, err := caClient.EnableCertificateAuthority(ctx, req)
	if err != nil {
		return fmt.Errorf("EnableCertificateAuthority failed: %w", err)
	}

	var caResp *privatecapb.CertificateAuthority
	if caResp, err = op.Wait(ctx); err != nil {
		return fmt.Errorf("EnableCertificateAuthority failed during wait: %w", err)
	}

	if caResp.State != privatecapb.CertificateAuthority_ENABLED {
		return fmt.Errorf("unable to enable Certificate Authority. Current state: %s", caResp.State.String())
	}

	fmt.Fprintf(w, "Successfully enabled Certificate Authority: %s.", caId)
	return nil
}

Java

Pour vous authentifier auprès du service d'autorité de certification, configurez les 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.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 vous authentifier auprès du service d'autorité de certification, configurez les 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


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)

API REST

  1. Autorisez l'autorité de certification à émettre des certificats à partir du pool d'autorités de certification.

    Méthode HTTP et URL : 

    POST https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificateAuthorities/ROOT_CA_ID:enable

    Pour envoyer votre requête, développez l'une des options suivantes :

    Vous devriez recevoir une réponse JSON de ce type :

    {
    "name": "projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID",
    "metadata": {...},
    "done": false
}

  2. Interrogez l'opération jusqu'à ce qu'elle soit terminée.

    Méthode HTTP et URL : 

    GET https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID

    Pour envoyer votre requête, développez l'une des options suivantes :

    Vous devriez recevoir une réponse JSON de ce type :

    {
    "name": "projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID",
    "metadata": {...},
    "done": true,
    "response": {
      "@type": "type.googleapis.com/google.cloud.security.privateca.v1.CertificateAuthority",
      "name": "...",
    }
}

Tester une autorité de certification

Pour vérifier qu'une autorité de certification peut émettre des certificats, demandez un certificat au pool d'autorités de certification associé et mentionnez explicitement le nom de l'autorité de certification que vous souhaitez tester à l'aide de l'indicateur --ca.

Vous pouvez utiliser les méthodes suivantes pour demander un certificat à partir d'un pool d'autorités de certification:

  1. Demandez au service CA de créer une clé privée ou publique pour vous.
  2. Générez votre propre clé privée ou publique, puis envoyez une requête de signature de certificat (CSR).

Il est plus facile d'utiliser une clé privée ou publique générée automatiquement pour demander un certificat à une autorité de certification dans un pool d'autorités de certification. Cette section fournit des informations sur le test d'une autorité de certification à l'aide de cette méthode.

Pour utiliser une clé privée ou publique générée automatiquement pour demander un certificat à une autorité de certification dans un pool d'autorités de certification, exécutez la commande gcloud suivante:

gcloud privateca certificates create \
    --issuer-pool=POOL_ID \
    --issuer-location=ISSUER_LOCATION \
    --ca=ROOT_CA_ID \
    --generate-key \
    --key-output-file=KEY_FILENAME \
    --cert-output-file=CERT_FILENAME \
    --dns-san=DNS_NAME

Remplacez les éléments suivants :

  • POOL_ID: nom du pool d'autorités de certification.
  • ISSUER_LOCATION: emplacement de l'autorité de certification (CA) qui a émis le certificat numérique.
  • ROOT_CA_ID: identifiant unique de l'autorité de certification que vous souhaitez tester.
  • KEY_FILENAME: fichier dans lequel la clé générée est écrite au format PEM.
  • CERT_FILENAME: fichier dans lequel le fichier de chaîne de certificats encodé au format PEM est écrit. L'ordre de la chaîne de certificats est de la feuille à la racine.

  • DNS_NAME: un ou plusieurs autres noms d'objet DNS (SAN, Subject Alternative Name) séparés par une virgule.

    L'indicateur --generate-key génère une nouvelle clé privée RSA-2048 sur votre ordinateur.

Pour utiliser une demande de signature de certificat (CSR) afin de demander un certificat à une autorité de certification dans un pool d'autorités de certification, ou pour en savoir plus sur les demandes de certificats, consultez Demander un certificat et afficher les certificats émis.

Cloner des autorités de certification

Pour cloner une autorité de certification existante afin de la renouveler ou pour créer une autorité de certification avec la même configuration, exécutez la commande suivante:

gcloud privateca roots create NEW_CA_ID \
    --location=LOCATION \
    --pool=POOL_ID \
    --from-ca=EXISTING_CA_ID \
    --key-algorithm "ec-p384-sha384"

Remplacez les éléments suivants :

  • NEW_CA_ID: identifiant unique de la nouvelle autorité de certification.
  • LOCATION: emplacement du pool d'autorités de certification.
  • POOL_ID: nom du pool d'autorités de certification dans lequel vous souhaitez créer l'autorité de certification.
  • EXISTING_CA_ID: ID de l'autorité de certification source ou identifiant complet de l'autorité de certification source.

L'indicateur --from-ca est compatible avec la création d'autorités de certification racine et subordonnées. L'autorité de certification existante doit appartenir au même pool d'autorités de certification que la nouvelle autorité de certification.

L'indicateur --key-algorithm copie toute la configuration de l'autorité de certification à partir de l'autorité de certification existante (à l'exception de la version de clé Cloud KMS et du bucket Cloud Storage). Toutefois, vous pouvez toujours remplacer l'une des valeurs de configuration de la nouvelle autorité de certification en fournissant explicitement l'indicateur approprié. Par exemple, vous pouvez toujours spécifier `--subject SUBJECT pour utiliser un nouveau sujet.

Si vous omettez l'option --key-algorithm, l'algorithme est défini par défaut sur:

  • rsa-pkcs1-4096-sha256 pour les autorités de certification racine.
  • rsa-pkcs1-2048-sha256 pour les autorités de certification subordonnées.

Pour en savoir plus sur cette commande gcloud, consultez gcloud privateca roots create.

Étape suivante