Diese Seite wurde von der Cloud Translation API übersetzt.

Zertifikat anfordern

Auf dieser Seite wird beschrieben, wie Sie eine Zertifikatsanfrage in Certificate Authority Service erstellen.

Sie können ein Zertifikat mit den folgenden Methoden anfordern:

Eigenen privaten oder öffentlichen Schlüssel generieren und Zertifikatsignierung einreichen Anfrage (CSR):
Verwenden Sie einen privaten oder öffentlichen Schlüssel, der von CA Service automatisch generiert wurde.
Vorhandenen Cloud Key Management Service-Schlüssel (Cloud KMS) verwenden

Hinweise

Umgebung für den CA-Dienst vorbereiten
Wenden Sie sich an Ihren Administrator, um die Berechtigungen zu erhalten, die Sie zum Ausstellen von Zertifikaten benötigen um Ihnen den Zertifikatanfrageer für CA Service (roles/privateca.certificateRequester) zu gewähren, oder IAM des CA Service Certificate Manager (roles/privateca.certificateManager) Rolle.

Weitere Informationen zu den vordefinierten IAM-Rollen für Weitere Informationen zu CA Service finden Sie unter Zugriffssteuerung mit IAM.

Informationen zum Zuweisen einer IAM-Rolle an ein Hauptkonto finden Sie unter Einzelne Rolle zuweisen.

Zertifikat mit einer CSR anfordern

Um ein Zertifikat zu erhalten, generieren Sie eine CSR, mit der Sie das Zertifikat anfordern.

CSR generieren

Eine ausführliche Anleitung zum Generieren einer CSR mit OpenSSL finden Sie Siehe CSR mit OpenSSL generieren. Sie können beim Generieren auch die folgende Beispielkonfigurationsdatei als Referenz verwenden. an Ihren Kundenbetreuer wenden können.

So verwenden Sie die Beispielkonfigurationsdatei:

Erstellen Sie mit der folgenden Konfiguration eine Konfigurationsdatei mit dem Namen csr.cnf.
```
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
```
Dieses Beispiel generiert einen 2048-Bit-RSA-Schlüssel (Passphrasenverschlüsselung) und eine entsprechende CSR Enthält Folgendes:
- das Attribut commonName im Betreff-DN
- Erweiterung subjectAlternativeName
- Die Erweiterung keyUsage (als kritisch markiert)
- extendedKeyUsage-Erweiterung
Ändern Sie die Parameter nach Bedarf. Konfigurationsdatei x509v3_config verwenden Format zur Definition von Erweiterungen für X.509-Zertifikate und CSRs finden Sie in der OpenSSL-Dokumentation.
Führen Sie den folgenden openssl-Befehl aus, um eine CSR und einen entsprechenden privaten Schlüssel zu generieren:
```
openssl req -newkey rsa:2048 -out csr.pem -keyout key.pem -config csr.cnf
```
Mit diesem Befehl werden die folgenden Dateien generiert:
- csr.pem: Ihre CSR, die bei einer Zertifizierungsstelle eingereicht werden kann
- key.pem: Ihren privaten Schlüssel, den Sie sicher aufbewahren sollten
Verwenden Sie die Datei csr.pem in Ihrer Zertifikatsanfrage.

Zertifikatsanfrage mit der CSR senden

So fordern Sie ein Zertifikat mithilfe der CSR an:

Console

Rufen Sie in der Google Cloud Console die Seite Certificate Authority Service auf.

Zum Certificate Authority Service
Klicken Sie auf Zertifikat anfordern.
Wählen Sie eine Region aus. Die Region muss mit der Region des CA-Pools übereinstimmen, den Sie verwenden möchten.
Wählen Sie einen Zertifizierungsstellenpool aus.
Optional: Wählen Sie eine bestimmte Zertifizierungsstelle aus dem Zertifizierungsstellenpool aus. Wenn Sie eine bestimmte CA für die Zertifikatsausstellung erstellen, erstellen Sie eine Abhängigkeit von dieser Zertifizierungsstelle, wodurch es schwieriger wird, Zertifizierungsstellen rotieren.
Optional: Wählen Sie eine Zertifikatsvorlage aus. Wenn Sie eine Zertifikatsvorlage verwenden, dass die Richtlinien der Zertifikatsvorlage nicht mit dem Richtlinien des ausgewählten Zertifizierungsstellenpools.
Klicken Sie auf Certificate Signing Request (CSR) angeben und dann auf Weiter. Die Zertifikatsdetails werden angezeigt.
Optional: Automatisch generiertes Zertifikat überschreiben Namen haben, geben Sie den benutzerdefinierten Namen in das Feld Zertifikatname ein. Nach dem Zertifikat erstellt wurde, können Sie es nicht löschen oder wiederverwenden Namen.
Optional: Um einen benutzerdefinierten Gültigkeitszeitraum für das Zertifikat auszuwählen, geben Sie den Wert im Feld Gültig für.
Kopieren Sie die CSR-Anfrage und fügen Sie sie in das Feld Certificate CSR ein. Wenn Sie möchten Um eine Datei mit der Zertifikatsanfrage hochzuladen, klicken Sie auf Durchsuchen und wählen Sie Ihre Datei aus.
Klicken Sie auf Zertifikat generieren.

Signiertes Zertifikat herunterladen

Klicken Sie auf Zertifikat ansehen und dann auf Ansehen, um das generierte Zertifikat aufzurufen.
Klicken Sie auf , um das Zertifikat zu kopieren. Wenn Sie das Zertifikat als .crt-Datei herunterladen möchten, klicken Sie auf Zertifikat herunterladen.
Optional: Klicken Sie zum Herunterladen der Zertifikatskette auf Zertifikatskette herunterladen.

gcloud

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

Ersetzen Sie Folgendes:

CERT_ID: Die eindeutige Kennung des Zertifikats.
POOL_ID: Der Name des CA-Pools.
CSR_FILENAME: Die Datei, in der die PEM-codierte CSR gespeichert ist.

Das Flag --validity definiert die Gültigkeitsdauer des Zertifikats. Es ist ein optionales Flag, dessen Standardwert 30 Tage beträgt.

Weitere Informationen zum Befehl gcloud privateca certificates create finden Sie unter 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"
  }
}

REST API

Generieren Sie mit Ihrer bevorzugten Methode einen Zertifizierungsantrag (Certificate Signing Request, CSR) wie openssl.

Im Folgenden sehen Sie eine Beispiel-CSR, die für JSON codiert ist.

Fordern Sie ein Zertifikat an.

HTTP-Methode und URL:
```
POST https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificates?certificate_id=CERTIFICATE_ID
```
JSON-Text anfordern:
```
{
 "lifetime": {
   "seconds": 3600,
   "nanos": 0
 },
 "pem_csr": "PEM_CSR"
}
```
Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:
curl (Linux, macOS oder Cloud Shell)

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto bei der gcloud-Befehlszeile angemeldet haben. Dazu haben Sie gcloud init oder gcloud auth login ausgeführt oder die Cloud Shell genutzt, die Sie automatisch bei der gcloud-Befehlszeile anmeldet. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:
```
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)

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto bei der gcloud-Befehlszeile angemeldet haben. Dazu führen Sie gcloud init oder gcloud auth login aus. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:
```
$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
```
Sie sollten in etwa folgende JSON-Antwort erhalten:
```
{
 "name": "projects/project-id/locations/location/certificateAuthorities/ca-id/certificates/certificate-id",
 "pemCertificate": "-----BEGIN CERTIFICATE-----...",
 "certificateDescription": {...}
}
```
Achtung :Wir empfehlen, Zertifikate der Endentität nicht über eine Stammentität auszustellen. Zertifizierungsstelle. Informationen zum Erstellen untergeordneter Zertifizierungsstellen finden Sie unter Zertifizierungsstellen erstellen.

Zertifikat mit einem automatisch generierten Schlüssel anfordern

Console

Mit der Google Cloud Console können Sie Client- oder Server-TLS-Zertifikate generieren.

Rufen Sie in der Google Cloud Console die Seite Certificate Authority Service auf.

Zum Certificate Authority Service
Klicken Sie auf Zertifikat anfordern.
Wählen Sie eine Region aus. Die Region muss mit der Region des CA-Pools übereinstimmen, den Sie verwenden möchten.
Wählen Sie einen Zertifizierungsstellenpool aus.
Klicken Sie auf Details manuell eingeben. Die Zertifikatsdetails werden angezeigt.
Optional: Ersetzen Sie den automatisch generierten Zertifikatnamen durch einen benutzerdefinierten der eindeutig ist.
Optional: Um einen benutzerdefinierten Gültigkeitszeitraum für das Zertifikat auszuwählen, geben Sie den Wert im Feld Gültig für.

Domainnamen hinzufügen

Geben Sie unter Domainnamen hinzufügen im Feld Domainname 1 einen Domainnamen ein.
Optional: Wenn Sie mehr als einen Domainnamen hinzufügen möchten, klicken Sie auf Hinzufügen Element und geben Sie einen weiteren Domainnamen in das Feld Domainname 2 ein.

Erweiterte Schlüsselverwendung

Optional: Wählen Sie unter Erweiterte Schlüsselverwendung eine der folgenden Optionen aus: je nach Anwendungsfall:
- Client-TLS: Mit diesen Zertifikaten können Sie die Identität eines Anfragenden authentifizieren.
- Server-TLS: Mit diesen Zertifikaten können Sie die Identität authentifizieren. eines Servers.
Klicken Sie auf Weiter.

Schlüsselgröße und Algorithmus konfigurieren

Optional: Wählen Sie unter Schlüsselgröße und Algorithmus konfigurieren die gewünschte Signatur aus. Schlüsselgröße und Algorithmus aus der Liste. Wenn Sie diesen Schritt überspringen, Es wird ein RSASSA-PSS-2048-Bit-Schlüssel mit einem SHA-256-Digest verwendet. Weitere Informationen Informationen zur Auswahl eines Signaturschlüssels und Algorithmus finden Sie unter Schlüsselalgorithmus auswählen.
Klicken Sie auf Zertifikat generieren.

Signiertes Zertifikat herunterladen

Klicken Sie auf Zertifikat ansehen und dann auf Ansehen, um das generierte Zertifikat aufzurufen.
Optional: Klicken Sie zum Herunterladen der PEM-codierten Zertifikatskette auf Zertifikatskette herunterladen
Optional: Klicken Sie zum Herunterladen des zugehörigen PEM-codierten privaten Schlüssels auf Laden Sie den privaten Schlüssel herunter.

Wichtig: Nachdem Sie diese Seite verlassen haben, können Sie diesen Schlüssel nicht mehr abrufen. Dieses Schlüssel ist vertraulich. Wir empfehlen, den Schlüssel an einem sicheren Ort zu schützen.
Wichtig: Wenn Sie einen DevOps-CA-Pool verwenden, ist dies das einzige Mal, dass Sie Laden Sie das erstellte Zertifikat herunter. CA Service speichert nicht nach diesem Bildschirm auf den Inhalt des Zertifikats an.

gcloud

Um die Funktion für automatisch generierte Schlüssel nutzen zu können, müssen Sie die Python- PyCA-Bibliothek (Cryptographic Authority, PyCA). Eine Anleitung zum Installieren der Pyca Cryptography-Bibliothek finden Sie unter Pyca Cryptography-Bibliothek einbinden.

Verwenden Sie den folgenden gcloud-Befehl, um ein Zertifikat zu erstellen:

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"

Ersetzen Sie Folgendes:

POOL_ID: Der Name des CA-Pools.
KEY_FILENAME: Der Pfad, in dem die generierte muss eine private Schlüsseldatei geschrieben werden.
CERT_FILENAME: der Pfad, unter dem die PEM-codierte Zertifikatskettendatei geschrieben werden muss. Die Zertifikatskette ist von der Endentität zum Stamm.
DNS_NAME: Ein oder mehrere durch Kommas getrennte alternative DNS-Inhabernamen (Subject Alternative Names, SANs).
CERTIFICATE_PROFILE: Die eindeutige Kennung von das Zertifikatsprofil. Verwenden Sie beispielsweise leaf_server_tls für den TLS-Endknotenserver.

Im Befehl gcloud werden die folgenden Flags angegeben:

--generate-key: Generiert einen neuen privaten RSA-2048-Schlüssel auf Ihrem Computer.

Sie können auch eine beliebige Kombination der folgenden Flags verwenden:

--dns-san: Hiermit können Sie eine oder mehrere durch Kommas getrennte DNS-SANs übergeben.
--ip-san: Hiermit können Sie einen oder mehrere durch Kommas getrennte IP-SANs übergeben.
--uri-san: Hiermit können Sie einen oder mehrere durch Kommas getrennte URI-SANs übergeben.
--subject: Damit übergeben Sie den X.501-Namen des Zertifikats. Person.

Weitere Informationen zum Befehl gcloud privateca certificates create finden Sie unter gcloud privateca certificates create.

Go

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei CA Service zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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)

Zertifikat mit einem vorhandenen Cloud KMS-Schlüssel anfordern

Sie können nur mit der Google Cloud CLI Zertifikate mit einem Cloud KMS-Schlüssel anfordern.

gcloud

So erstellen Sie mithilfe eines Cloud KMS-Schlüssels ein TLS-Zertifikat für den Server der Endentität: führen Sie den folgenden Befehl aus:

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"

Ersetzen Sie Folgendes:

POOL_ID: Der Name des Zertifizierungsstellenpools.
PROJECT_ID: die Projekt-ID
LOCATION_ID: Der Speicherort des Schlüsselbunds.
KEY_RING: der Name des Schlüsselbunds, in dem der Schlüssel befindet.
KEY: der Name des Schlüssels
KEY_VERSION: Die Version des Schlüssels.
CERT_FILENAME: Pfad des PEM-codierten Zertifikatkettendatei. Die Zertifikatkettendatei wird nach der Endentität sortiert. auf Root-Ebene.
DNS_NAME: Kommagetrennte DNS-SANs.

Zertifikat von einer bestimmten Zertifizierungsstelle in einem Zertifizierungsstellenpool ausstellen

In diesem Abschnitt wird beschrieben, wie Sie Zertifikate von einer bestimmten Zertifizierungsstelle in einem Zertifizierungsstellenpool ausstellen.

Console

Rufen Sie in der Google Cloud Console die Seite Certificate Authority Service auf.

Zum Certificate Authority Service
Klicken Sie auf Zertifikat anfordern.
Wählen Sie eine Region aus. Die Region muss mit der Region des CA-Pools übereinstimmen, den Sie verwenden möchten.
Wählen Sie einen Zertifizierungsstellenpool aus.
Klicken Sie auf Eine bestimmte Zertifizierungsstelle aus diesem Zertifizierungsstellenpool verwenden und wählen Sie dann eine Zertifizierungsstelle aus der Liste aus.
Wählen Sie wie im Abschnitt Zertifikat mit einem automatisch generierten Schlüssel anfordern oder Zertifikat mit einer CSR anfordern andere Parameter aus. .

gcloud

Wenn Sie die Zertifikatsausstellung auf eine bestimmte Zertifizierungsstelle im CA-Pool ausrichten möchten, fügen Sie den Parameter Das Flag --ca mit der CA_ID der Zertifizierungsstelle, die das Zertifikat ausstellen muss.

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
}

Zertifikat im Validierungsmodus anfordern

Wenn Sie ein Zertifikat im Validierungsmodus anfordern, wird ein ungesigniertes Testzertifikat erstellt. Dieses Testzertifikat ist nicht PEM-codiert und es fallen keine Kosten an. Sie können das Zertifikat zwar nicht herunterladen, aber die Beschreibung des hypothetischen Zertifikats können Sie bestätigen, dass Sie ein signiertes Zertifikat mit dem von Ihnen ausgewählten Parameter.

So fordern Sie ein Zertifikat im Validierungsmodus an:

Console

Rufen Sie in der Google Cloud Console die Seite Certificate Authority Service auf.

Zum Certificate Authority Service
Klicken Sie auf Zertifikat anfordern.
Wählen Sie Validierungsmodus für die Beschreibung eines hypothetischen Zertifikats anstelle eines signierten Zertifikats verwenden aus.
Führen Sie dieselben Schritte aus, um ein signiertes Zertifikat anzufordern.

Zertifikat anfordern

Hinweise

Zertifikat mit einer CSR anfordern

CSR generieren

Zertifikatsanfrage mit der CSR senden

Console

gcloud

Terraform

REST API

curl (Linux, macOS oder Cloud Shell)

PowerShell (Windows)

Zertifikat mit einem automatisch generierten Schlüssel anfordern

Console

gcloud

Go

Java

Python

Zertifikat mit einem vorhandenen Cloud KMS-Schlüssel anfordern

gcloud

Zertifikat von einer bestimmten Zertifizierungsstelle in einem Zertifizierungsstellenpool ausstellen

Console

gcloud

Terraform

Zertifikat im Validierungsmodus anfordern

Console

Nächste Schritte