Diese Seite wurde von der Cloud Translation API übersetzt.

Zertifikat anfordern und ausgestellte Zertifikate ansehen

In diesem Thema wird beschrieben, wie Sie ein Zertifikat vom Certificate Authority Service anfordern und die ausgestellten Zertifikate aufrufen können.

Hinweise

Sie benötigen die IAM-Rolle „CA Service Certificate Anforderer“ (roles/privateca.certificateRequester) oder die IAM-Rolle „CA Service Certificate Manager“ (roles/privateca.certificateManager). Weitere Informationen zu den vordefinierten IAM-Rollen für CA Service finden Sie unter Zugriffssteuerung mit IAM.

Informationen zum Zuweisen einer IAM-Rolle zu einem Hauptkonto finden Sie unter Eine einzelne Rolle zuweisen.

Überblick

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

Generieren Sie Ihren eigenen privaten oder öffentlichen Schlüssel und senden Sie eine Anfrage zur Zertifikatssignierung (Certificate Signing Request, CSR).
Lassen Sie den CA Service einen privaten oder öffentlichen Schlüssel für Sie erstellen.
Vorhandenen Cloud Key Management Service-Schlüssel (Cloud KMS) verwenden

Zertifikat mit einem CSR anfordern

Bevor Sie fortfahren, müssen Sie eine CSR generieren. Nachdem Sie eine CSR generiert haben, gehen Sie so vor:

Console

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

Zum Certificate Authority Service
Klicken Sie auf den Tab CA Manager.
Klicken Sie auf den Namen der Zertifizierungsstelle, von der Sie die Ausstellung stellen möchten.
Klicken Sie unten auf der Detailseite der Zertifizierungsstelle auf Zertifikat anfordern.
Optional: Wenn Sie eine Zertifikatsvorlage verwenden möchten, klicken Sie auf , wählen Sie eine Vorlage aus der Liste aus und klicken Sie auf Speichern.
Klicken Sie auf CSR bereitstellen.
Optional: Wenn Sie den automatisch generierten Zertifikatsnamen überschreiben möchten, geben Sie den benutzerdefinierten Namen in das Feld Zertifikatname ein.
Optional: Wenn Sie einen benutzerdefinierten Gültigkeitszeitraum für das Zertifikat auswählen möchten, geben Sie den Wert in das Feld Gültig für ein.
Kopieren Sie Ihre CSR und fügen Sie sie in das Feld Certificate CSR ein. Klicken Sie zum Hochladen der CSR auf Browse (Durchsuchen).
Klicken Sie auf Next (Weiter).

Signiertes Zertifikat herunterladen

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.
Klicken Sie auf Fertig.

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 Zertifizierungsstellenpools.
CSR_FILENAME: Die Datei, in der die PEM-codierte CSR gespeichert wird.

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

Weitere Informationen zum Befehl gcloud privateca certificates create finden Sie unter gcloud privatecacertificate 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 eine Anfrage zur Signierung des Zertifikats mit Ihrer bevorzugten Methode, z. B. openssl.

Im Folgenden finden Sie ein Beispiel für einen CSR, der 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 der Anfrage:
```
{
 "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 in der gcloud CLI angemeldet haben. Dazu haben Sie gcloud init oder gcloud auth login ausgeführt oder die Cloud Shell genutzt, die Sie automatisch in der gcloud CLI 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 in der gcloud CLI angemeldet haben. Dazu haben Sie gcloud init oder gcloud auth login ausgeführt oder die Cloud Shell genutzt, die Sie automatisch in der gcloud CLI 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:
```
$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, keine Zertifikate für Endentitäten von einer Stammzertifizierungsstelle auszustellen. 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 TLS-Zertifikate für Clients oder Server generieren.

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

Zum Certificate Authority Service
Klicken Sie auf den Tab CA Manager.
Klicken Sie auf den Namen der Zertifizierungsstelle, von der Sie die Ausstellung stellen möchten.
Klicken Sie unten auf der Detailseite Zertifizierungsstelle auf Zertifikat anfordern.
Optional: Wenn Sie eine Zertifikatsvorlage verwenden möchten, klicken Sie auf , wählen Sie eine Vorlage aus der Liste aus und klicken Sie auf Speichern.
Klicken Sie auf Details eingeben.
Optional: Ersetzen Sie den automatisch generierten Zertifikatnamen durch einen benutzerdefinierten Namen, der eindeutig ist.
Optional: Wenn Sie einen benutzerdefinierten Gültigkeitszeitraum für das Zertifikat auswählen möchten, geben Sie den Wert in das Feld Gültig für ein.

Domainnamen hinzufügen

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

Erweiterte Schlüsselverwendung

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

Schlüsselgröße und Algorithmus konfigurieren

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

Signiertes Zertifikat herunterladen

Optional: Klicken Sie zum Herunterladen der PEM-codierten Zertifikatskette auf Zertifikatskette herunterladen.
Optional: Klicken Sie auf Privaten Schlüssel herunterladen, um den zugehörigen PEM-codierten privaten Schlüssel herunterzuladen.

Wichtig: Sie können diesen Schlüssel nach Verlassen dieser Seite nicht mehr abrufen. Dieser Schlüssel ist vertraulich. Wir empfehlen, den Schlüssel an einem sicheren Ort zu schützen.
Klicken Sie auf Fertig.

Wichtig: Wenn Sie einen DevOps-CA-Pool verwenden, können Sie das erstellte Zertifikat nur jetzt herunterladen. CA Service speichert den Inhalt des Zertifikats über diesen Bildschirm hinaus nicht.

gcloud

Wenn Sie das Feature für automatisch generierte Schlüssel verwenden möchten, müssen Sie die PyCA-Bibliothek (Python Cryptographic Authority) installieren. 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 Zertifizierungsstellenpools.
KEY_FILENAME: Der Pfad, in den die generierte private Schlüsseldatei geschrieben werden muss.
CERT_FILENAME: Der Pfad, in den die PEM-codierte Zertifikatskettendatei geschrieben werden muss. Die Zertifikatskette ist von der Endentität bis zum Stamm sortiert.
DNS_NAME: Ein oder mehrere durch Kommas getrennte DNS-Subject Alternative Names (SANs).
CERTIFICATE_PROFILE: Die eindeutige Kennung des Zertifikatsprofils. Verwenden Sie beispielsweise leaf_server_tls für TLS für den Endentitätsserver.

Der Befehl gcloud erwähnt die folgenden Flags:

--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 ein oder mehrere durch Kommas getrennte DNS-SANs übergeben.
--ip-san: Hiermit können Sie ein oder mehrere durch Kommas getrennte IP-SANs übergeben.
--uri-san: Hiermit können Sie ein oder mehrere durch Kommas getrennte URI-SANs übergeben.
--subject: Hiermit können Sie einen X.501-Namen des Zertifikatssubjekts übergeben.

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

Einfach loslegen (Go)

Richten Sie für die Authentifizierung beim CA Service Standardanmeldedaten für Anwendungen ein. 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

Führen Sie den folgenden Befehl aus, um mit einem Cloud KMS-Schlüssel ein TLS-Zertifikat eines Endentitätsservers zu erstellen:

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 sich der Schlüssel befindet.
KEY: der Name des Schlüssels
KEY_VERSION: Die Version des Schlüssels.
CERT_FILENAME: Der Pfad der PEM-codierten Zertifikatskettendatei. Die Datei der Zertifikatskette wird von der Endentität bis zum Stamm sortiert.
DNS_NAME: kommagetrennte DNS-SANs.

Häufige Vorgänge mit Zertifikaten durchführen

In diesem Abschnitt wird beschrieben, wie Sie bestimmte gängige Vorgänge mit Zertifikaten ausführen können.

Zertifikat von einer bestimmten Zertifizierungsstelle in einem Zertifizierungsstellenpool ausstellen

gcloud

Wenn Sie eine bestimmte Zertifizierungsstelle im Zertifizierungsstellenpool für die Zertifikatsausstellung als Ziel verwenden möchten, fügen Sie das Flag --ca mit dem CA_ID der Zertifizierungsstelle hinzu, 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"

Console

Die Google Cloud Console unterstützt nur das Ausstellen von Zertifikaten von einer bestimmten Zertifizierungsstelle. Folgen Sie der Anleitung im Abschnitt Zertifikat mit einem automatisch generierten Schlüssel anfordern oder Zertifikat über CSR anfordern, um die Zertifizierungsstelle auszuwählen, die das Zertifikat ausstellen muss.

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
}

Ausgestellte Zertifikate ansehen

Console

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

Zum Certificate Authority Service
Klicken Sie auf den Tab CA-Manager.
Klicken Sie auf der Seite Zertifizierungsstellen auf den Namen der Zertifizierungsstelle.
Klicken Sie unten auf der Detailseite Zertifizierungsstelle auf Ausgestellte Zertifikate ansehen, um die Liste der von der Zertifizierungsstelle ausgestellten Zertifikate aufzurufen.

Die Zertifikate werden auf der Seite Alle Zertifikate angezeigt. Dazu gehören der Status des Zertifikats, die ausstellende Zertifizierungsstelle, der CA-Pool, der die Zertifizierungsstelle enthält, das Ablaufdatum des Zertifikats und mehr.

gcloud

Verwenden Sie den folgenden gcloud-Befehl, um alle von einer bestimmten Zertifizierungsstelle ausgestellten Zertifikate in einem CA-Pool aufzulisten:

gcloud privateca certificates list --issuer-pool ISSUER_POOL --ca CA_NAME

Weitere Informationen zum Befehl gcloud privateca certificates list finden Sie unter gcloud privatecacertificate list.

Verwenden Sie den folgenden gcloud-Befehl, um alle Zertifikate aller Zertifizierungsstellen an einem bestimmten Standort aufzulisten:

gcloud privateca certificates list --location LOCATION

Einfach loslegen (Go)

import (
	"context"
	"fmt"
	"io"

	privateca "cloud.google.com/go/security/privateca/apiv1"
	"cloud.google.com/go/security/privateca/apiv1/privatecapb"
	"google.golang.org/api/iterator"
)

// List Certificates present in the given CA pool.
func listCertificates(
	w io.Writer,
	projectId string,
	location string,
	caPoolId string) error {
	// projectId := "your_project_id"
	// location := "us-central1"		// For a list of locations, see: https://cloud.google.com/certificate-authority-service/docs/locations.
	// caPoolId := "ca-pool-id"			// The CA Pool id in which the certificate exists.

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

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

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

	it := caClient.ListCertificates(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("unable to get the list of cerficates: %w", err)
		}

		fmt.Fprintf(w, " - %s (common name: %s)", resp.Name,
			resp.CertificateDescription.SubjectDescription.Subject.CommonName)
	}

	return nil
}

Java


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 java.io.IOException;

public class ListCertificates {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // location: For a list of locations, see:
    // https://cloud.google.com/certificate-authority-service/docs/locations
    // poolId: Id of the CA pool which contains the certificates to be listed.
    String project = "your-project-id";
    String location = "ca-location";
    String poolId = "ca-pool-id";
    listCertificates(project, location, poolId);
  }

  // List Certificates present in the given CA pool.
  public static void listCertificates(String project, String location, String poolId)
      throws 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()) {

      CaPoolName caPool =
          CaPoolName.newBuilder()
              .setProject(project)
              .setLocation(location)
              .setCaPool(poolId)
              .build();

      // Retrieve and print the certificate names.
      System.out.println("Available certificates: ");
      for (Certificate certificate :
          certificateAuthorityServiceClient.listCertificates(caPool).iterateAll()) {
        System.out.println(certificate.getName());
      }
    }
  }
}

Python


import google.cloud.security.privateca_v1 as privateca_v1

def list_certificates(
    project_id: str,
    location: str,
    ca_pool_name: str,
) -> None:
    """
    List Certificates present in the given CA pool.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        location: location you want to use. For a list of locations, see: https://cloud.google.com/certificate-authority-service/docs/locations.
        ca_pool_name: name of the CA pool which contains the certificates to be listed.
    """

    caServiceClient = privateca_v1.CertificateAuthorityServiceClient()

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

    # Retrieve and print the certificate names.
    print(f"Available certificates in CA pool {ca_pool_name}:")
    for certificate in caServiceClient.list_certificates(parent=ca_pool_path):
        print(certificate.name)

Details für ein einzelnes Zertifikat ansehen

Console

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

Zum Certificate Authority Service
Wählen Sie auf dem Tab CA-Manager Ihre Ziel-Zertifizierungsstelle aus.
Klicken Sie auf den Namen der Zertifizierungsstelle.
Klicken Sie unten auf der Detailseite Zertifizierungsstelle auf Ausgestellte Zertifikate ansehen, um eine Liste der ausgestellten Zertifikate aufzurufen.
Klicken Sie in der Spalte Aktionen für das Zertifikat, das Sie herunterladen möchten, auf .
Klicken Sie unter Herunterladen auf Zertifikat. Sie können die Zertifikatskette herunterladen. Klicken Sie dazu auf Zertifikatskette.

gcloud

Führen Sie den folgenden Befehl aus, um die vollständige Beschreibung eines Zertifikats anzusehen:

gcloud privateca certificates describe CERT_NAME \
    --issuer-pool POOL_ID

Weitere Informationen zum Befehl gcloud privateca certificates describe finden Sie unter gcloud privateca zertifikate.

Führen Sie den folgenden Befehl aus, um die PEM-codierte X.509-Zertifikatskette in eine Datei zu exportieren:

gcloud privateca certificates export CERT_NAME \
    --issuer-pool POOL_ID \
    --include-chain \
    --output-file certificate-file

Weitere Informationen zum Befehl gcloud privateca certificates export finden Sie unter gcloud privateca certificate export.

Besitznachweis für Zertifikate

Der Besitznachweis des privaten Schlüssels stellt sicher, dass der Anforderer eines Zertifikats den privaten Schlüssel für dieses Zertifikat besitzt. CA Service prüft den Besitznachweis nur, wenn der Anforderer eine PKCS #10-CSR gemäß RFC 2986 bereitstellt. Der Besitznachweis für andere Arten von Zertifikatsanfragen, z. B. Anfragen durch CertificateConfig, wird nicht erzwungen.

Es liegt in der Verantwortung von Clientanwendungen, die Zertifikate akzeptieren, um zu prüfen, ob der Zertifikatsinhaber den privaten Schlüssel dieses Zertifikats besitzt. Das Erzwingen von Eigentumsprüfungen während der Zertifikatsausstellung ist eine gestaffelte Form der gestaffelten Sicherheitsebenen zum Schutz vor fehlerhaften Clients. Das Vorhandensein solcher Clients könnte unabhängig davon, ob die Zertifizierungsstelle den Existenznachweis überprüft, eine Sicherheitslücke darstellen.

Zertifikat anfordern und ausgestellte Zertifikate ansehen

Hinweise

Überblick

Zertifikat mit einem CSR anfordern

Console

gcloud

Terraform

REST API

curl (Linux, macOS oder Cloud Shell)

PowerShell (Windows)

Zertifikat mit einem automatisch generierten Schlüssel anfordern

Console

gcloud

Einfach loslegen (Go)

Java

Python

Zertifikat mit einem vorhandenen Cloud KMS-Schlüssel anfordern

Häufige Vorgänge mit Zertifikaten durchführen

Zertifikat von einer bestimmten Zertifizierungsstelle in einem Zertifizierungsstellenpool ausstellen

gcloud

Console

Terraform

Ausgestellte Zertifikate ansehen

Console

gcloud

Einfach loslegen (Go)

Java

Python

Details für ein einzelnes Zertifikat ansehen

Console

gcloud

Besitznachweis für Zertifikate

Nächste Schritte