Cette page a été traduite par l'API Cloud Translation.

Demander un certificat

Cette page explique comment créer une demande de certificat dans Certificate Authority Service.

Vous pouvez demander un certificat en utilisant les méthodes suivantes :

Générez votre propre clé privée ou publique et envoyez une signature de certificat Requête (CSR).
Utilisez une clé privée ou publique générée automatiquement par CA Service.
Utiliser une clé Cloud Key Management Service (Cloud KMS) existante.

Avant de commencer

Préparez votre environnement pour le service de certification.
Pour obtenir les autorisations nécessaires pour émettre des certificats, demandez à votre administrateur de vous accorder le rôle IAM Demandeur de certificat du service CA (roles/privateca.certificateRequester) ou Gestionnaire de certificats du service CA (roles/privateca.certificateManager).

Pour en savoir plus sur les rôles IAM prédéfinis pour CA Service, consultez la page Contrôle des accès avec IAM.

Pour savoir comment attribuer un rôle IAM à un principal, consultez la section Attribuer un rôle unique.

Demander un certificat à l'aide d'une CSR

Pour obtenir un certificat, vous devez générer une requête de signature de certificat que vous utiliserez ensuite pour demander le certificat.

Générer la requête de signature de certificat

Pour obtenir des instructions détaillées sur la façon de générer une requête de signature de certificat à l’aide d’OpenSSL, consultez la page Générer une requête de signature de certificat avec OpenSSL. Vous pouvez également utiliser l'exemple de fichier de configuration suivant comme référence lors de la génération votre requête de signature de certificat.

Pour utiliser l'exemple de fichier de configuration, procédez comme suit :

Créez un fichier de configuration nommé csr.cnf à l'aide de la configuration suivante.
```
cat << EOF > csr.cnf
[req]
distinguished_name = req_distinguished_name
req_extensions = v3_req
prompt = no

[req_distinguished_name]
CN = example.com

[v3_req]
keyUsage = critical, digitalSignature, keyEncipherment
extendedKeyUsage = serverAuth
subjectAltName = @alt_names

[alt_names]
DNS.1 = example.com
DNS.2 = www.example.com
EOF
```
Cet exemple génère une clé RSA de 2 048 bits (phrase secrète chiffrée) et une requête de signature de certificat correspondante. contenant les éléments suivants:
- Attribut commonName dans le nom distinctif de l'objet
- l'extension subjectAlternativeName
- l'extension keyUsage (marquée comme critique)
- l'extension extendedKeyUsage
Modifiez les paramètres selon vos besoins. Pour utiliser le fichier de configuration x509v3_config pour définir les extensions des certificats X.509 et des requêtes de signature de certificat, consultez la documentation OpenSSL.
Exécutez la commande openssl suivante pour générer une requête de signature de certificat et la clé privée correspondante:
```
openssl req -newkey rsa:2048 -out csr.pem -keyout key.pem -config csr.cnf
```
Cette commande génère les fichiers suivants:
- csr.pem: votre requête de signature de certificat, prête à être envoyée à une autorité de certification.
- key.pem : votre clé privée, que vous devez conserver de manière sécurisée
Utilisez le fichier csr.pem dans votre requête de certificat.

Envoyer une demande de certificat à l'aide de la CSR

Pour demander un certificat à l'aide du CSR, procédez comme suit :

Console

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

Accéder à Certificate Authority Service
Cliquez sur Demander un certificat.
Sélectionnez une région. La région doit être identique à celle du pool d'autorités de certification que vous prévoyez d'utiliser.
Sélectionnez un pool d'autorités de certification.
Facultatif : sélectionnez une autorité de certification spécifique dans le pool. Notez que lorsque vous choisissez un type CA pour l’émission de certificats, vous créez une dépendance sur cette AC, ce qui la rend plus difficile effectuer la rotation des CA.
(Facultatif) Choisissez un modèle de certificat. Si vous utilisez un modèle de certificat, assurez-vous que ses règles n'entrent pas en conflit avec celles du pool d'autorités de certification sélectionné.
Cliquez sur Fournir une demande de signature de certificat (CSR), puis sur Suivant. Les détails du certificat s'affichent.
Facultatif : Pour écraser le nom du certificat généré automatiquement, saisissez le nom personnalisé dans le champ Nom du certificat. Une fois le certificat créé, vous ne pouvez plus supprimer ni réutiliser son nom.
Facultatif : pour choisir une période de validité personnalisée pour le certificat, saisissez la valeur dans le champ Valid for (Valide pour).
Copiez et collez votre requête de signature de certificat dans la zone CSR de certificat. Si vous souhaitez importer un fichier contenant la CSR, cliquez sur Parcourir, puis sélectionnez votre fichier.
Cliquez sur Générer un certificat.

Télécharger le certificat signé

Pour afficher le certificat généré, cliquez sur Afficher le certificat, puis sur Afficher.
Pour copier le certificat, cliquez sur . Pour télécharger le certificat au format de fichier .crt, cliquez sur Télécharger le certificat.
Facultatif: Pour télécharger la chaîne de certificats, cliquez sur Télécharger la chaîne de certificats

gcloud

gcloud privateca certificates create CERT_ID \
     --issuer-pool POOL_ID \
     --csr CSR_FILENAME \
     --cert-output-file CERT_FILENAME \
     --validity "P30D"

Remplacez les éléments suivants :

CERT_ID : identifiant unique du certificat.
POOL_ID: nom du pool d'autorités de certification.
CSR_FILENAME: fichier qui stocke la requête de signature de certificat encodée au format PEM.

L'indicateur --validity définit la durée de validité du certificat. Il s'agit d'un indicateur facultatif dont la valeur par défaut est de 30 jours.

Pour plus d'informations sur la commande gcloud privateca certificates create, consultez la page sur la commande gcloud privateca certificate create.

Terraform

resource "google_privateca_certificate_authority" "test_ca" {
  pool                     = "my-pool"
  certificate_authority_id = "my-certificate-authority"
  location                 = "us-central1"
  deletion_protection      = false # set to true to prevent destruction of the resource
  config {
    subject_config {
      subject {
        organization = "HashiCorp"
        common_name  = "my-certificate-authority"
      }
      subject_alt_name {
        dns_names = ["hashicorp.com"]
      }
    }
    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 {
          server_auth = false
        }
      }
    }
  }
  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
}


resource "google_privateca_certificate" "default" {
  pool                  = "my-pool"
  location              = "us-central1"
  certificate_authority = google_privateca_certificate_authority.test_ca.certificate_authority_id
  lifetime              = "860s"
  name                  = "my-certificate"
  pem_csr               = tls_cert_request.example.cert_request_pem
}

resource "tls_private_key" "example" {
  algorithm = "RSA"
}

resource "tls_cert_request" "example" {
  private_key_pem = tls_private_key.example.private_key_pem

  subject {
    common_name  = "example.com"
    organization = "ACME Examples, Inc"
  }
}

API REST

Générez une requête de signature de certificat (CSR) à l'aide de la méthode de votre choix, par exemple openssl.

Voici un exemple de requête de signature de certificat encodée pour JSON.

Demandez un certificat.

Méthode HTTP et URL :
```
POST https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificates?certificate_id=CERTIFICATE_ID
```
Corps JSON de la requête :
```
{
 "lifetime": {
   "seconds": 3600,
   "nanos": 0
 },
 "pem_csr": "PEM_CSR"
}
```
Pour envoyer votre requête, développez l'une des options suivantes :
curl (Linux, macOS ou Cloud Shell)

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificates?certificate_id=CERTIFICATE_ID"
```
PowerShell (Windows)

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificates?certificate_id=CERTIFICATE_ID" | Select-Object -Expand Content
```
Vous devriez recevoir une réponse JSON de ce type :
```
{
 "name": "projects/project-id/locations/location/certificateAuthorities/ca-id/certificates/certificate-id",
 "pemCertificate": "-----BEGIN CERTIFICATE-----...",
 "certificateDescription": {...}
}
```
Attention :Nous vous recommandons de ne pas émettre de certificats d'entité de fin à partir d'une adresse CA. Pour en savoir plus sur la création d'autorités de certification subordonnées, consultez Créer des autorités de certification.

Demander un certificat à l'aide d'une clé générée automatiquement

Console

Vous pouvez utiliser la console Google Cloud pour générer des certificats TLS côté client ou serveur.

Accédez à la page Certificate Authority Service de la console Google Cloud.

Accéder à Certificate Authority Service
Cliquez sur Demander un certificat.
Sélectionnez une région. La région doit être identique à celle du pool d'autorités de certification que vous prévoyez d'utiliser.
Sélectionnez un pool d'autorités de certification.
Cliquez sur Saisir les détails manuellement. Les détails du certificat s'affichent.
(Facultatif) Remplacez le nom du certificat généré automatiquement par un nom personnalisé unique.
Facultatif: Pour choisir une période de validité personnalisée pour le certificat, saisissez la valeur du champ Valide pour.

Ajouter un nom de domaine

Sous Ajouter un nom de domaine, saisissez un nom de domaine dans le champ Nom de domaine 1.
Facultatif : Si vous souhaitez ajouter plusieurs noms de domaine, cliquez sur Ajouter un élément, puis saisissez un autre nom de domaine dans le champ Nom de domaine 2.

Utilisation étendue des clés

Facultatif : Sous Utilisation étendue des clés, sélectionnez l'une des options suivantes en fonction de votre cas d'utilisation :
- TLS client : ces certificats vous permettent d'authentifier l'identité d'un demandeur.
- TLS du serveur: ces certificats vous permettent d'authentifier l'identité d'un serveur.
Cliquez sur Suivant.

Configurer l'algorithme et la taille de clé

Facultatif: Sous Configurer la taille et l'algorithme de la clé, sélectionnez l'option de signature la taille de clé et l'algorithme de la liste. Si vous ignorez cette étape, une clé RSASSA-PSS de 2 048 bits avec un condensé SHA-256 est utilisée. Pour plus d'informations sur la sélection d'une clé de signature et d'un algorithme, consultez Choisir un algorithme de clé.
Cliquez sur Générer un certificat.

Télécharger le certificat signé

Pour afficher le certificat généré, cliquez sur Afficher le certificat, puis sur Afficher.
Facultatif : Pour télécharger la chaîne de certificats encodée au format PEM, cliquez sur Télécharger la chaîne de certificats.
Facultatif: Pour télécharger la clé privée encodée au format PEM qui est associée, cliquez sur Téléchargez la clé privée.

Important :Vous ne pourrez pas récupérer cette clé après avoir quitté cette page. Ce est sensible. Nous vous recommandons de protéger la clé dans un emplacement sécurisé.
Important :Si vous utilisez un pool d'autorités de certification DevOps, c'est le seul moment où vous pouvez téléchargez le certificat créé. CA Service ne stocke pas le contenu du certificat au-delà de cet écran.

gcloud

Pour utiliser la fonctionnalité de clé générée automatiquement, vous devez installer la bibliothèque Python Cryptographic Authority (PyCA). Pour obtenir des instructions sur l'installation de la bibliothèque de cryptographie Pyca, consultez la section Inclure la bibliothèque de cryptographie Pyca.

Pour créer un certificat, utilisez la commande gcloud suivante:

gcloud privateca certificates create \
  --issuer-pool POOL_ID \
  --generate-key \
  --key-output-file KEY_FILENAME \
  --cert-output-file CERT_FILENAME \
  --dns-san "DNS_NAME" \
  --use-preset-profile "CERTIFICATE_PROFILE"

Remplacez les éléments suivants :

POOL_ID : nom du pool d'autorités de certification.
KEY_FILENAME : chemin d'accès au fichier de clé privée généré.
CERT_FILENAME: chemin d'accès où la valeur le fichier de chaîne de certificats doit être écrit. La chaîne de certificats est ordonné de l'entité de fin à la racine.
DNS_NAME: un ou plusieurs noms d'objet DNS (SAN) séparés par une virgule.
CERTIFICATE_PROFILE : identifiant unique du profil de certificat. Par exemple, utilisez leaf_server_tls pour le TLS du serveur d'entité finale.

La commande gcloud mentionne les options suivantes:

--generate-key : génère une nouvelle clé privée RSA-2048 sur votre machine.

Vous pouvez également utiliser n'importe quelle combinaison des indicateurs suivants :

--dns-san: permet de transmettre un ou plusieurs SAN DNS séparés par une virgule.
--ip-san: permet de transmettre un ou plusieurs réseaux IP SAN séparés par une virgule.
--uri-san: permet de transmettre un ou plusieurs URI SAN séparés par une virgule.
--subject : vous permet de transmettre un nom X.501 de l'objet du certificat.

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

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 a Certificate which is issued by the Certificate Authority present in the CA Pool.
// The key used to sign the certificate is created by the Cloud KMS.
func createCertificate(
	w io.Writer,
	projectId string,
	location string,
	caPoolId string,
	caId string,
	certId string,
	commonName string,
	domainName string,
	certDuration int64,
	publicKeyBytes []byte) 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 in which the certificate authority exists.
	// caId := "ca-id"					// The name of the certificate authority which issues the certificate.
	// certId := "certificate"			// A unique name for the certificate.
	// commonName := "cert-name"		// A common name for the certificate.
	// domainName := "cert.example.com"	// Fully qualified domain name for the certificate.
	// certDuration := int64(31536000)	// The validity of the certificate in seconds.
	// publicKeyBytes 					// The public key used in signing the certificates.

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

	// Set the Public Key and its format.
	publicKey := &privatecapb.PublicKey{
		Key:    publicKeyBytes,
		Format: privatecapb.PublicKey_PEM,
	}

	// Set Certificate subject config.
	subjectConfig := &privatecapb.CertificateConfig_SubjectConfig{
		Subject: &privatecapb.Subject{
			CommonName: commonName,
		},
		SubjectAltName: &privatecapb.SubjectAltNames{
			DnsNames: []string{domainName},
		},
	}

	// Set the X.509 fields required for the certificate.
	x509Parameters := &privatecapb.X509Parameters{
		KeyUsage: &privatecapb.KeyUsage{
			BaseKeyUsage: &privatecapb.KeyUsage_KeyUsageOptions{
				DigitalSignature: true,
				KeyEncipherment:  true,
			},
			ExtendedKeyUsage: &privatecapb.KeyUsage_ExtendedKeyUsageOptions{
				ServerAuth: true,
				ClientAuth: true,
			},
		},
	}

	// Set certificate settings.
	cert := &privatecapb.Certificate{
		CertificateConfig: &privatecapb.Certificate_Config{
			Config: &privatecapb.CertificateConfig{
				PublicKey:     publicKey,
				SubjectConfig: subjectConfig,
				X509Config:    x509Parameters,
			},
		},
		Lifetime: &durationpb.Duration{
			Seconds: certDuration,
		},
	}

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

	// Create the CreateCertificateRequest.
	// See https://pkg.go.dev/cloud.google.com/go/security/privateca/apiv1/privatecapb#CreateCertificateRequest.
	req := &privatecapb.CreateCertificateRequest{
		Parent:                        fullCaPoolName,
		CertificateId:                 certId,
		Certificate:                   cert,
		IssuingCertificateAuthorityId: caId,
	}

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

	fmt.Fprintf(w, "Certificate %s created", certId)

	return nil
}

Java


import com.google.api.core.ApiFuture;
import com.google.cloud.security.privateca.v1.CaPoolName;
import com.google.cloud.security.privateca.v1.Certificate;
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.CreateCertificateRequest;
import com.google.cloud.security.privateca.v1.KeyUsage;
import com.google.cloud.security.privateca.v1.KeyUsage.ExtendedKeyUsageOptions;
import com.google.cloud.security.privateca.v1.KeyUsage.KeyUsageOptions;
import com.google.cloud.security.privateca.v1.PublicKey;
import com.google.cloud.security.privateca.v1.PublicKey.KeyFormat;
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.protobuf.ByteString;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class CreateCertificate {

  public static void main(String[] args)
      throws InterruptedException, ExecutionException, IOException {
    // TODO(developer): Replace these variables before running the sample.

    // publicKeyBytes: Public key used in signing the certificates.
    // 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.
    // certificateAuthorityName: The name of the certificate authority which issues the certificate.
    // certificateName: Set a unique name for the certificate.
    String project = "your-project-id";
    ByteString publicKeyBytes = ByteString.copyFrom(new byte[]{});
    String location = "ca-location";
    String poolId = "ca-poolId";
    String certificateAuthorityName = "certificate-authority-name";
    String certificateName = "certificate-name";

    createCertificate(
        project, location, poolId, certificateAuthorityName, certificateName, publicKeyBytes);
  }

  // Create a Certificate which is issued by the Certificate Authority present in the CA Pool.
  // The public key used to sign the certificate can be generated using any crypto
  // library/framework.
  public static void createCertificate(
      String project,
      String location,
      String poolId,
      String certificateAuthorityName,
      String certificateName,
      ByteString publicKeyBytes)
      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()) {

      // commonName: Enter a title for your certificate.
      // orgName: Provide the name of your company.
      // domainName: List the fully qualified domain name.
      // certificateLifetime: The validity of the certificate in seconds.
      String commonName = "commonname";
      String orgName = "orgname";
      String domainName = "dns.example.com";
      long certificateLifetime = 1000L;

      // Set the Public Key and its format.
      PublicKey publicKey =
          PublicKey.newBuilder().setKey(publicKeyBytes).setFormat(KeyFormat.PEM).build();

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

      // Set the X.509 fields required for the certificate.
      X509Parameters x509Parameters =
          X509Parameters.newBuilder()
              .setKeyUsage(
                  KeyUsage.newBuilder()
                      .setBaseKeyUsage(
                          KeyUsageOptions.newBuilder()
                              .setDigitalSignature(true)
                              .setKeyEncipherment(true)
                              .setCertSign(true)
                              .build())
                      .setExtendedKeyUsage(
                          ExtendedKeyUsageOptions.newBuilder().setServerAuth(true).build())
                      .build())
              .setCaOptions(CaOptions.newBuilder().setIsCa(true).buildPartial())
              .build();

      // Create certificate.
      Certificate certificate =
          Certificate.newBuilder()
              .setConfig(
                  CertificateConfig.newBuilder()
                      .setPublicKey(publicKey)
                      .setSubjectConfig(subjectConfig)
                      .setX509Config(x509Parameters)
                      .build())
              .setLifetime(Duration.newBuilder().setSeconds(certificateLifetime).build())
              .build();

      // Create the Certificate Request.
      CreateCertificateRequest certificateRequest =
          CreateCertificateRequest.newBuilder()
              .setParent(CaPoolName.of(project, location, poolId).toString())
              .setCertificateId(certificateName)
              .setCertificate(certificate)
              .setIssuingCertificateAuthorityId(certificateAuthorityName)
              .build();

      // Get the Certificate response.
      ApiFuture<Certificate> future =
          certificateAuthorityServiceClient
              .createCertificateCallable()
              .futureCall(certificateRequest);

      Certificate response = future.get();
      // Get the PEM encoded, signed X.509 certificate.
      System.out.println(response.getPemCertificate());
      // To verify the obtained certificate, use this intermediate chain list.
      System.out.println(response.getPemCertificateChainList());
    }
  }
}

Python

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


def create_certificate(
    project_id: str,
    location: str,
    ca_pool_name: str,
    ca_name: str,
    certificate_name: str,
    common_name: str,
    domain_name: str,
    certificate_lifetime: int,
    public_key_bytes: bytes,
) -> None:
    """
    Create a Certificate which is issued by the Certificate Authority present in the CA Pool.
    The key used to sign the certificate is created by the Cloud KMS.

    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 a unique name for the CA pool.
        ca_name: the name of the certificate authority which issues the certificate.
        certificate_name: set a unique name for the certificate.
        common_name: a title for your certificate.
        domain_name: fully qualified domain name for your certificate.
        certificate_lifetime: the validity of the certificate in seconds.
        public_key_bytes: public key used in signing the certificates.
    """

    caServiceClient = privateca_v1.CertificateAuthorityServiceClient()

    # The public key used to sign the certificate can be generated using any crypto library/framework.
    # Also you can use Cloud KMS to retrieve an already created public key.
    # For more info, see: https://cloud.google.com/kms/docs/retrieve-public-key.

    # Set the Public Key and its format.
    public_key = privateca_v1.PublicKey(
        key=public_key_bytes,
        format_=privateca_v1.PublicKey.KeyFormat.PEM,
    )

    subject_config = privateca_v1.CertificateConfig.SubjectConfig(
        subject=privateca_v1.Subject(common_name=common_name),
        subject_alt_name=privateca_v1.SubjectAltNames(dns_names=[domain_name]),
    )

    # Set the X.509 fields required for the certificate.
    x509_parameters = privateca_v1.X509Parameters(
        key_usage=privateca_v1.KeyUsage(
            base_key_usage=privateca_v1.KeyUsage.KeyUsageOptions(
                digital_signature=True,
                key_encipherment=True,
            ),
            extended_key_usage=privateca_v1.KeyUsage.ExtendedKeyUsageOptions(
                server_auth=True,
                client_auth=True,
            ),
        ),
    )

    # Create certificate.
    certificate = privateca_v1.Certificate(
        config=privateca_v1.CertificateConfig(
            public_key=public_key,
            subject_config=subject_config,
            x509_config=x509_parameters,
        ),
        lifetime=duration_pb2.Duration(seconds=certificate_lifetime),
    )

    # Create the Certificate Request.
    request = privateca_v1.CreateCertificateRequest(
        parent=caServiceClient.ca_pool_path(project_id, location, ca_pool_name),
        certificate_id=certificate_name,
        certificate=certificate,
        issuing_certificate_authority_id=ca_name,
    )
    result = caServiceClient.create_certificate(request=request)

    print("Certificate creation result:", result)

Demander un certificat à l'aide d'une clé Cloud KMS existante

Vous ne pouvez utiliser la CLI Google Cloud que pour demander des certificats à l'aide d'une clé Cloud KMS.

gcloud

Pour créer un certificat TLS du serveur d'entité finale à l'aide d'une clé Cloud KMS, exécutez la commande suivante:

gcloud privateca certificates create \
  --issuer-pool POOL_ID \
  --kms-key-version projects/PROJECT_ID/locations/LOCATION_ID/keyRings/KEY_RING/cryptoKeys/KEY/cryptoKeyVersions/KEY_VERSION \
  --cert-output-file CERT_FILENAME \
  --dns-san "DNS_NAME" \
  --use-preset-profile "leaf_server_tls"

Remplacez les éléments suivants :

POOL_ID: nom du pool d'autorités de certification.
PROJECT_ID : ID du projet
LOCATION_ID: emplacement du trousseau de clés
KEY_RING: nom du trousseau de clés dans lequel la clé se trouve.
KEY : nom de la clé.
KEY_VERSION : version de la clé.
CERT_FILENAME : chemin d'accès au fichier de chaîne de certificats encodé au format PEM. Le fichier de chaîne de certificats est trié par rapport à l'entité de fin à la racine.
DNS_NAME : SAN DNS séparés par des virgules.

Émettre un certificat à partir d'une autorité de certification spécifique dans un pool d'autorités de certification

Cette section explique comment émettre des certificats à partir d'une autorité de certification spécifique dans un pool d'autorités de certification.

Console

Accédez à la page Certificate Authority Service de la console Google Cloud.

Accéder à Certificate Authority Service
Cliquez sur Demander un certificat.
Sélectionnez une région. La région doit être identique à celle du pool d'autorités de certification que vous prévoyez d'utiliser.
Sélectionnez un pool d'autorités de certification.
Pour choisir une autorité de certification, cliquez sur Utiliser une autorité de certification spécifique de ce pool d'autorités de certification, puis sélectionnez une autorité de certification de la liste.
Sélectionnez d'autres paramètres comme vous l'avez fait dans la section Demander un certificat à l'aide d'une clé générée automatiquement ou Demander un certificat à l'aide d'une CSR.

gcloud

Pour cibler une autorité de certification spécifique dans le pool d'autorités de certification en vue de l'émission du certificat, ajoutez le l'option --ca avec le CA_ID de l'autorité de certification qui doit émettre le certificat ;

gcloud privateca certificates create \
  --issuer-pool POOL_ID \
  --ca CA_ID \
  --generate-key \
  --key-output-file KEY_FILENAME \
  --cert-output-file CERT_FILENAME \
  --dns-san "DNS_NAME" \
  --use-preset-profile "leaf_server_tls"

Terraform

resource "google_privateca_certificate_authority" "authority" {
  // 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-sample-certificate-authority"
  location                 = "us-central1"
  deletion_protection      = false # set to true to prevent destruction of the resource
  config {
    subject_config {
      subject {
        organization = "HashiCorp"
        common_name  = "my-certificate-authority"
      }
      subject_alt_name {
        dns_names = ["hashicorp.com"]
      }
    }
    x509_config {
      ca_options {
        is_ca = true
      }
      key_usage {
        base_key_usage {
          digital_signature = true
          cert_sign         = true
          crl_sign          = true
        }
        extended_key_usage {
          server_auth = true
        }
      }
    }
  }
  lifetime = "86400s"
  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
}


resource "google_privateca_certificate" "default" {
  pool     = "my-pool"
  location = "us-central1"
  lifetime = "860s"
  name     = "my-sample-certificate"
  config {
    subject_config {
      subject {
        common_name         = "san1.example.com"
        country_code        = "us"
        organization        = "google"
        organizational_unit = "enterprise"
        locality            = "mountain view"
        province            = "california"
        street_address      = "1600 amphitheatre parkway"
        postal_code         = "94109"
      }
    }
    x509_config {
      ca_options {
        is_ca = false
      }
      key_usage {
        base_key_usage {
          crl_sign = true
        }
        extended_key_usage {
          server_auth = true
        }
      }
    }
    public_key {
      format = "PEM"
      key    = base64encode(data.tls_public_key.example.public_key_pem)
    }
  }
  // Certificates require an authority to exist in the pool, though they don't
  // need to be explicitly connected to it
  depends_on = [google_privateca_certificate_authority.authority]
}

resource "tls_private_key" "example" {
  algorithm = "RSA"
}

data "tls_public_key" "example" {
  private_key_pem = tls_private_key.example.private_key_pem
}

Demander un certificat en mode validation

Demander un certificat en mode validation crée un certificat de test non signé. Ce certificat de test n'est pas encodé au format PEM et n'entraîne aucuns frais. Bien que vous ne puissiez pas télécharger le certificat, la description hypothétique du certificat vous permet de confirmer que vous pouvez émettre un certificat signé avec les paramètres de votre choix.

Pour demander un certificat en mode validation, procédez comme suit :

Console

Accédez à la page Certificate Authority Service de la console Google Cloud.

Accéder à Certificate Authority Service
Cliquez sur Demander un certificat.
Sélectionnez Utiliser le mode validation pour une description de certificat fictif au lieu d'un certificat signé.
Suivez la même procédure que pour demander un certificat signé.

Étape suivante

En savoir plus sur les profils de certificat
Découvrez comment révoquer des certificats.
Découvrez comment trier et filtrer les certificats.
Découvrez comment gérer des certificats à l'aide de la Google Cloud CLI.

Demander un certificat

Avant de commencer

Demander un certificat à l'aide d'une CSR

Générer la requête de signature de certificat

Envoyer une demande de certificat à l'aide de la CSR

Console

gcloud

Terraform

API REST

curl (Linux, macOS ou Cloud Shell)

PowerShell (Windows)

Demander un certificat à l'aide d'une clé générée automatiquement

Console

gcloud

Go

Java

Python

Demander un certificat à l'aide d'une clé Cloud KMS existante

gcloud

Émettre un certificat à partir d'une autorité de certification spécifique dans un pool d'autorités de certification

Console

gcloud

Terraform

Demander un certificat en mode validation

Console

Étape suivante