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 à l'aide des méthodes suivantes:

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

Avant de commencer

Préparez votre environnement pour le service CA.
Pour obtenir les autorisations nécessaires pour émettre des certificats, demandez à votre administrateur de vous attribuer le rôle IAM Demandeur de certificats 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 le service CA, consultez la page Contrôle des accès avec IAM.

Pour en savoir plus sur l'attribution d'un rôle IAM à un compte principal, consultez la section Attribuer un rôle unique.

Demander un certificat à l'aide d'une requête de signature de certificat

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 génération d'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 de 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:
- L'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 format de fichier de configuration x509v3_config afin de définir des extensions pour les certificats X.509 et les 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 sécuriser
Utilisez le fichier csr.pem dans votre demande de certificat.

Envoyer une demande de certificat à l'aide de la requête de signature de certificat

Pour demander un certificat à l'aide de la requête de signature de certificat, 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 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 d'autorités de certification. Notez que lorsque vous choisissez une autorité de certification spécifique pour l'émission du certificat, vous créez une dépendance à cette autorité de certification, ce qui rend la rotation des autorités de certification plus difficile.
Facultatif: choisissez un modèle de certificat. Si vous utilisez un modèle de certificat, assurez-vous que les règles du modèle de certificat n'entrent pas en conflit avec les règles 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 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 requête de signature de certificat, cliquez sur Parcourir, puis sélectionnez votre fichier.
Cliquez sur Générer un certificat.

Télécharger le certificat signé

Pour voir 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 sous la forme d'un 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'option --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 demande de signature de certificat (CSR) en utilisant 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 autorité de certification racine. Pour en savoir plus sur la création d'autorités de certification subordonnées, consultez la page 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 dans le 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 de la clé, 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 de 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 la taille et l'algorithme de la clé de signature dans la liste. Si vous ignorez cette étape, une clé RSASA-PSS de 2 048 bits avec un condensé SHA 256 est utilisée. Pour en savoir plus 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 voir 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 associée, cliquez sur Télécharger la clé privée.

Important :Vous ne pourrez pas récupérer cette clé après avoir quitté cette page. Cette clé 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écharger 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 PyCA (Python Cryptographic Authority). Pour savoir comment installer la bibliothèque de cryptographie Pyca, consultez 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 où le fichier de clé privée généré doit être écrit.
CERT_FILENAME: chemin d'accès dans lequel le fichier de chaîne de certificats encodé au format PEM doit être écrit. La chaîne de certificats est classée de l'entité finale à 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 protocole TLS du serveur d'entité de fin.

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 options suivantes:

--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 plus d'informations sur la commande gcloud privateca certificates create, consultez la page sur la commande gcloud privateca certificate create.

Go

Pour vous authentifier auprès du service CA, 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 Google Cloud CLI 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 contenant la clé.
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 ordonné de l'entité de fin à la racine.
DNS_NAME: réseaux SAN DNS séparés par une virgule.

É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 dans la liste.
Sélectionnez d'autres paramètres comme vous l'avez fait dans les sections Demander un certificat à l'aide d'une clé générée automatiquement ou Demander un certificat à l'aide d'une requête de signature de certificat.

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 l'option --ca avec l'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 du certificat hypothétique vous permet de vérifier 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é.

Étapes suivantes

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 les certificats à l'aide de la Google Cloud CLI.

Demander un certificat

Avant de commencer

Demander un certificat à l'aide d'une requête de signature de certificat

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

Envoyer une demande de certificat à l'aide de la requête de signature de certificat

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

Étapes suivantes