Root-Zertifizierungsstelle erstellen

Auf dieser Seite wird beschrieben, wie Sie eine Root-Zertifizierungsstelle in einem Zertifizierungsstellenpool erstellen.

Eine Stammzertifizierungsstelle befindet sich an der Spitze einer Public-Key-Infrastrukturhierarchie (PKI). Sie ist für die Bildung des Vertrauensankers der PKI verantwortlich. Damit Zertifikate in einer PKI ordnungsgemäß verwendet werden können und diese ordnungsgemäß verwendet werden können, muss ein Gerät, eine Software oder eine Komponente der PKI vertrauen. Dazu wird das Gerät, die Software oder die Komponente so konfiguriert, dass der Stamm-CA vertraut wird. Daher sind alle von der Root-Zertifizierungsstelle ausgestellten Zertifikate vertrauenswürdig.

Hinweise

Stamm-CA erstellen

Eine Root-Zertifizierungsstelle hat ein selbst signiertes Zertifikat, das Sie an die Trust Stores Ihrer Clients verteilen müssen. Das Zertifikat der Root-Zertifizierungsstelle befindet sich am Anfang der Zertifikatskette. Keine andere Zertifizierungsstelle kann das CA-Zertifikat widerrufen. Die Zertifikatssperrliste gilt nur für die anderen Zertifikate, die von der Root-Zertifizierungsstelle ausgestellt wurden, aber nicht für sich selbst.

Console

So erstellen Sie eine Stammzertifizierungsstelle:

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

    Zum Certificate Authority Service

  2. Klicken Sie auf den Tab CA-Manager.

  3. Klicken Sie auf Zertifizierungsstelle erstellen.

CA-Typ auswählen

So konfigurieren Sie die dauerhaften Einstellungen der Zertifizierungsstelle wie Stufe, Standort, Lebensdauer und Betriebszustand bei der Erstellung:

  1. Wählen Sie Root-Zertifizierungsstelle aus.
  2. Geben Sie im Feld Gültig für den Zeitraum ein, während dessen die vom CA-Zertifikat ausgestellten Zertifikate gültig sein sollen.
  3. Optional: Wählen Sie eine Stufe für die Zertifizierungsstelle aus.
  4. Klicken Sie auf Region und wählen Sie in der Liste den Standort aus, an dem Sie die Zertifizierungsstelle erstellen möchten. Wir empfehlen, die Zertifizierungsstelle geografisch in der Nähe der Clients Ihrer Anwendung zu erstellen. Weitere Informationen finden Sie unter Besten Standort auswählen.

  5. Optional: Wählen Sie den Betriebsstatus der Zertifizierungsstelle aus, in der erstellt werden soll.

    Wählen Sie den Vorgangsstatus der Zertifizierungsstelle aus, in der erstellt werden soll.

  6. Optional: Klicken Sie auf Zertifikatsprofil. Wählen Sie in der Liste das Zertifikatsprofil aus, das dem Typ der Zertifikate entspricht, die die Zertifizierungsstelle ausstellen soll.

  7. Klicken Sie auf Next (Weiter).

CA-Betreffnamen konfigurieren
  1. Geben Sie in das Feld Organisation (O) den Namen Ihres Unternehmens ein.
  2. Optional: Geben Sie im Feld Organisationseinheit (OE) die Untergruppe oder Geschäftseinheit des Unternehmens ein.
  3. Optional: Geben Sie in das Feld Landesname einen zweistelligen Ländercode ein.
  4. Optional: Geben Sie in das Feld Name des Bundesstaats/-landes den Namen Ihres Bundesstaates ein.
  5. Optional: Geben Sie in das Feld Ortsname den Namen der Stadt ein.
  6. Geben Sie in das Feld CA Common Name (CN) den Namen der Zertifizierungsstelle ein.
  7. Geben Sie im Feld Pool-ID den Namen des Zertifizierungsstellenpools ein. Sie können den Zertifizierungsstellenpool nach dem Erstellen der Zertifizierungsstelle nicht mehr ändern.
  8. Klicken Sie auf Next (Weiter).
Größe und Algorithmus des Zertifizierungsstellenschlüssels konfigurieren
  1. Wählen Sie den Schlüsselalgorithmus aus, der Ihre Anforderungen am besten erfüllt. Informationen zur Auswahl eines geeigneten Schlüsselalgorithmus finden Sie unter Schlüsselalgorithmus auswählen.
  2. Klicken Sie auf Next (Weiter).
CA-Artefakte konfigurieren

Die folgenden Schritte sind optional. Wenn Sie diese Schritte überspringen, gelten die Standardeinstellungen.

  1. Wählen Sie aus, ob Sie einen von Google verwalteten oder einen selbstverwalteten Cloud Storage-Bucket verwenden möchten.

    2. Wenn Sie keinen selbstverwalteten Cloud Storage-Bucket auswählen, erstellt CA Service einen von Google verwalteten Bucket am selben Standort wie die Zertifizierungsstelle.

  2. Wählen Sie aus, ob Sie das Veröffentlichen von Zertifikatssperrlisten (CRLs) und CA-Zertifikaten im Cloud Storage-Bucket deaktivieren möchten.

    3. Das Veröffentlichen von Zertifikatssperrlisten und Zertifizierungsstellen der Zertifizierungsstelle in einem Cloud Storage-Bucket ist standardmäßig aktiviert. Klicken Sie auf die Ein-/Aus-Schaltflächen, um diese Einstellungen zu deaktivieren.

  3. Klicken Sie auf Next (Weiter).
Labels hinzufügen

Die folgenden Schritte sind optional.

So fügen Sie der Zertifizierungsstelle Labels hinzu:

  1. Klicken Sie auf Element hinzufügen.
  2. Geben Sie im Feld Schlüssel 1 den Labelschlüssel ein.
  3. Geben Sie im Feld Wert 1 den Wert für das Label ein.
  4. Wenn Sie ein weiteres Label hinzufügen möchten, klicken Sie auf Element hinzufügen. Fügen Sie dann den Labelschlüssel und den Labelwert wie in den Schritten 2 und 3 beschrieben hinzu.
  5. Klicken Sie auf Next (Weiter).
Einstellungen prüfen

Prüfen Sie alle Einstellungen sorgfältig und klicken Sie dann auf Erstellen, um die Zertifizierungsstelle zu erstellen.

gcloud

  1. Führen Sie den folgenden Befehl aus, um einen Zertifizierungsstellenpool zu erstellen:

    gcloud privateca pools create POOL_ID

    Ersetzen Sie POOL_ID durch den Namen des Zertifizierungsstellenpools.

    Weitere Informationen finden Sie unter CA-Pool erstellen.

    Weitere Informationen zu diesem gcloud-Befehl finden Sie unter gcloud privatecapools create.

  2. Erstellen Sie eine neue Stammzertifizierungsstelle im erstellten Zertifizierungsstellenpool.

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

    Ersetzen Sie Folgendes:

    • ROOT_CA_ID: Der Name der Zertifizierungsstelle.
    • POOL_ID: Der Name des Zertifizierungsstellenpools.
    • KEY_ALGORITHM: Der Algorithmus zum Erstellen eines Cloud KMS-Schlüssels. Dieses Flag ist optional. Wenn Sie dieses Flag nicht angeben, wird der Schlüsselalgorithmus standardmäßig auf rsa-pkcs1-4096-sha256 gesetzt. Weitere Informationen finden Sie unter --key-algorithmflag.

    Standardmäßig wird die Zertifizierungsstelle mit dem Status STAGED erstellt. Fügen Sie das Flag --auto-enable hinzu, um eine Zertifizierungsstelle standardmäßig zu aktivieren.

    Wenn Sie einen vom Kunden verwalteten Cloud Storage-Bucket zum Veröffentlichen von CA-Zertifikaten und Zertifikatssperrlisten verwenden möchten, fügen Sie dem Befehl --bucket bucket-name hinzu. Ersetzen Sie bucket-name durch den Namen des Cloud Storage-Bucket.

    Führen Sie den folgenden Befehl aus, um die vollständige Liste der Einstellungen aufzurufen:

    gcloud privateca roots create --help

Terraform

Verwenden Sie die folgende Beispielkonfiguration, um eine Stammzertifizierungsstelle mit einem von Google verwalteten Schlüssel zu erstellen:

resource "google_privateca_certificate_authority" "default" {
  // This example assumes this pool already exists.
  // Pools cannot be deleted in normal test circumstances, so we depend on static pools
  pool                     = "my-pool"
  certificate_authority_id = "my-certificate-authority-hashicorp"
  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
        max_issuer_path_length = 10
      }
      key_usage {
        base_key_usage {
          digital_signature  = true
          content_commitment = true
          key_encipherment   = false
          data_encipherment  = true
          key_agreement      = true
          cert_sign          = true
          crl_sign           = true
          decipher_only      = true
        }
        extended_key_usage {
          server_auth      = true
          client_auth      = false
          email_protection = true
          code_signing     = true
          time_stamping    = true
        }
      }
    }
  }
  lifetime = "86400s"
  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
}

Verwenden Sie die folgende Beispielkonfiguration, um eine Stammzertifizierungsstelle mit einem selbstverwalteten Schlüssel zu erstellen:

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

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

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

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

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

  config {
    subject_config {
      subject {
        organization = "Example, Org."
        common_name  = "Example Authority"
      }
    }
    x509_config {
      ca_options {
        # is_ca *MUST* be true for certificate authorities
        is_ca                  = true
        max_issuer_path_length = 10
      }
      key_usage {
        base_key_usage {
          # cert_sign and crl_sign *MUST* be true for certificate authorities
          cert_sign = true
          crl_sign  = true
        }
        extended_key_usage {
          server_auth = false
        }
      }
    }
  }

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

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

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

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

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

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

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

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

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

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

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

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

	return nil
}

Java

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 com.google.api.core.ApiFuture;
import com.google.cloud.security.privateca.v1.CaPoolName;
import com.google.cloud.security.privateca.v1.CertificateAuthority;
import com.google.cloud.security.privateca.v1.CertificateAuthority.KeyVersionSpec;
import com.google.cloud.security.privateca.v1.CertificateAuthority.SignHashAlgorithm;
import com.google.cloud.security.privateca.v1.CertificateAuthorityServiceClient;
import com.google.cloud.security.privateca.v1.CertificateConfig;
import com.google.cloud.security.privateca.v1.CertificateConfig.SubjectConfig;
import com.google.cloud.security.privateca.v1.CreateCertificateAuthorityRequest;
import com.google.cloud.security.privateca.v1.KeyUsage;
import com.google.cloud.security.privateca.v1.KeyUsage.KeyUsageOptions;
import com.google.cloud.security.privateca.v1.Subject;
import com.google.cloud.security.privateca.v1.X509Parameters;
import com.google.cloud.security.privateca.v1.X509Parameters.CaOptions;
import com.google.longrunning.Operation;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class CreateCertificateAuthority {

  public static void main(String[] args)
      throws InterruptedException, ExecutionException, IOException {
    // TODO(developer): Replace these variables before running the sample.
    // location: For a list of locations, see:
    // https://cloud.google.com/certificate-authority-service/docs/locations
    // poolId: Set it to the CA Pool under which the CA should be created.
    // certificateAuthorityName: Unique name for the CA.
    String project = "your-project-id";
    String location = "ca-location";
    String poolId = "ca-pool-id";
    String certificateAuthorityName = "certificate-authority-name";
    createCertificateAuthority(project, location, poolId, certificateAuthorityName);
  }

  // Create Certificate Authority which is the root CA in the given CA Pool.
  public static void createCertificateAuthority(
      String project, String location, String poolId, String certificateAuthorityName)
      throws InterruptedException, ExecutionException, IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `certificateAuthorityServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (CertificateAuthorityServiceClient certificateAuthorityServiceClient =
        CertificateAuthorityServiceClient.create()) {

      String commonName = "common-name";
      String orgName = "org-name";
      int caDuration = 100000; // Validity of this CA in seconds.

      // Set the type of Algorithm.
      KeyVersionSpec keyVersionSpec =
          KeyVersionSpec.newBuilder().setAlgorithm(SignHashAlgorithm.RSA_PKCS1_4096_SHA256).build();

      // Set CA subject config.
      SubjectConfig subjectConfig =
          SubjectConfig.newBuilder()
              .setSubject(
                  Subject.newBuilder().setCommonName(commonName).setOrganization(orgName).build())
              .build();

      //  Set the key usage options for X.509 fields.
      X509Parameters x509Parameters =
          X509Parameters.newBuilder()
              .setKeyUsage(
                  KeyUsage.newBuilder()
                      .setBaseKeyUsage(
                          KeyUsageOptions.newBuilder().setCrlSign(true).setCertSign(true).build())
                      .build())
              .setCaOptions(CaOptions.newBuilder().setIsCa(true).build())
              .build();

      // Set certificate authority settings.
      CertificateAuthority certificateAuthority =
          CertificateAuthority.newBuilder()
              // CertificateAuthority.Type.SELF_SIGNED denotes that this CA is a root CA.
              .setType(CertificateAuthority.Type.SELF_SIGNED)
              .setKeySpec(keyVersionSpec)
              .setConfig(
                  CertificateConfig.newBuilder()
                      .setSubjectConfig(subjectConfig)
                      .setX509Config(x509Parameters)
                      .build())
              // Set the CA validity duration.
              .setLifetime(Duration.newBuilder().setSeconds(caDuration).build())
              .build();

      // Create the CertificateAuthorityRequest.
      CreateCertificateAuthorityRequest certificateAuthorityRequest =
          CreateCertificateAuthorityRequest.newBuilder()
              .setParent(CaPoolName.of(project, location, poolId).toString())
              .setCertificateAuthorityId(certificateAuthorityName)
              .setCertificateAuthority(certificateAuthority)
              .build();

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

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

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

Python

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 google.cloud.security.privateca_v1 as privateca_v1
from google.protobuf import duration_pb2

def create_certificate_authority(
    project_id: str,
    location: str,
    ca_pool_name: str,
    ca_name: str,
    common_name: str,
    organization: str,
    ca_duration: int,
) -> None:
    """
    Create Certificate Authority which is the root CA in the given CA Pool. This CA will be
    responsible for signing certificates within this pool.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        location: location you want to use. For a list of locations, see: https://cloud.google.com/certificate-authority-service/docs/locations.
        ca_pool_name: set it to the CA Pool under which the CA should be created.
        ca_name: unique name for the CA.
        common_name: a title for your certificate authority.
        organization: the name of your company for your certificate authority.
        ca_duration: the validity of the certificate authority in seconds.
    """

    caServiceClient = privateca_v1.CertificateAuthorityServiceClient()

    # Set the types of Algorithm used to create a cloud KMS key.
    key_version_spec = privateca_v1.CertificateAuthority.KeyVersionSpec(
        algorithm=privateca_v1.CertificateAuthority.SignHashAlgorithm.RSA_PKCS1_4096_SHA256
    )

    # Set CA subject config.
    subject_config = privateca_v1.CertificateConfig.SubjectConfig(
        subject=privateca_v1.Subject(common_name=common_name, organization=organization)
    )

    # Set the key usage options for X.509 fields.
    x509_parameters = privateca_v1.X509Parameters(
        key_usage=privateca_v1.KeyUsage(
            base_key_usage=privateca_v1.KeyUsage.KeyUsageOptions(
                crl_sign=True,
                cert_sign=True,
            )
        ),
        ca_options=privateca_v1.X509Parameters.CaOptions(
            is_ca=True,
        ),
    )

    # Set certificate authority settings.
    certificate_authority = privateca_v1.CertificateAuthority(
        # CertificateAuthority.Type.SELF_SIGNED denotes that this CA is a root CA.
        type_=privateca_v1.CertificateAuthority.Type.SELF_SIGNED,
        key_spec=key_version_spec,
        config=privateca_v1.CertificateConfig(
            subject_config=subject_config,
            x509_config=x509_parameters,
        ),
        lifetime=duration_pb2.Duration(seconds=ca_duration),
    )

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

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

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

    print("Operation result:", result)

REST API

  1. Erstellen Sie eine Stamm-CA.

    HTTP-Methode und URL: 

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

    JSON-Text der Anfrage: 

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

    Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

    Sie sollten in etwa folgende JSON-Antwort erhalten:

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

  2. Fragen Sie den Vorgang ab, bis er abgeschlossen ist.

    HTTP-Methode und URL: 

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

    Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

    Sie sollten in etwa folgende JSON-Antwort erhalten:

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

Nachdem Sie sich vergewissert haben, dass die Zertifizierungsstelle wie erwartet funktioniert, können Sie sie aktivieren, um Load-Balancing-Zertifikate für den Zertifizierungsstellenpool auszustellen.

Stamm-CA aktivieren

gcloud

Führen Sie den folgenden gcloud-Befehl aus, um eine Stamm-CA zu aktivieren:

gcloud privateca roots enable ROOT_CA_ID --pool=POOL_ID

Ersetzen Sie Folgendes:

  • ROOT_CA_ID: Der Name der Zertifizierungsstelle.
  • POOL_ID: Der Name des Zertifizierungsstellenpools.

Terraform

Wenn Sie eine Root-Zertifizierungsstelle mit Terraform erstellen, wird sie beim Erstellen aktiviert. Wenn Sie eine Stamm-CA mit dem Status STAGED erstellen möchten, setzen Sie beim Erstellen der Zertifizierungsstelle das Feld desired_state auf STAGED.

Sie können das Feld desired_state nach dem Erstellen der Zertifizierungsstelle auf ENABLED oder DISABLED setzen.

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

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

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

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

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

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

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

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

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

Java

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 com.google.api.core.ApiFuture;
import com.google.cloud.security.privateca.v1.CertificateAuthority.State;
import com.google.cloud.security.privateca.v1.CertificateAuthorityName;
import com.google.cloud.security.privateca.v1.CertificateAuthorityServiceClient;
import com.google.cloud.security.privateca.v1.EnableCertificateAuthorityRequest;
import com.google.longrunning.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class EnableCertificateAuthority {

  public static void main(String[] args)
      throws InterruptedException, ExecutionException, IOException {
    // TODO(developer): Replace these variables before running the sample.
    // location: For a list of locations, see:
    // https://cloud.google.com/certificate-authority-service/docs/locations
    // poolId: The id of the CA pool under which the CA is present.
    // certificateAuthorityName: The name of the CA to be enabled.
    String project = "your-project-id";
    String location = "ca-location";
    String poolId = "ca-pool-id";
    String certificateAuthorityName = "certificate-authority-name";
    enableCertificateAuthority(project, location, poolId, certificateAuthorityName);
  }

  // Enable the Certificate Authority present in the given ca pool.
  // CA cannot be enabled if it has been already deleted.
  public static void enableCertificateAuthority(
      String project, String location, String poolId, String certificateAuthorityName)
      throws IOException, ExecutionException, InterruptedException {
    try (CertificateAuthorityServiceClient certificateAuthorityServiceClient =
        CertificateAuthorityServiceClient.create()) {
      // Create the Certificate Authority Name.
      CertificateAuthorityName certificateAuthorityParent =
          CertificateAuthorityName.newBuilder()
              .setProject(project)
              .setLocation(location)
              .setCaPool(poolId)
              .setCertificateAuthority(certificateAuthorityName)
              .build();

      // Create the Enable Certificate Authority Request.
      EnableCertificateAuthorityRequest enableCertificateAuthorityRequest =
          EnableCertificateAuthorityRequest.newBuilder()
              .setName(certificateAuthorityParent.toString())
              .build();

      // Enable the Certificate Authority.
      ApiFuture<Operation> futureCall =
          certificateAuthorityServiceClient
              .enableCertificateAuthorityCallable()
              .futureCall(enableCertificateAuthorityRequest);
      Operation response = futureCall.get();

      if (response.hasError()) {
        System.out.println("Error while enabling Certificate Authority !" + response.getError());
        return;
      }

      // Get the current CA state.
      State caState =
          certificateAuthorityServiceClient
              .getCertificateAuthority(certificateAuthorityParent)
              .getState();

      // Check if the CA is enabled.
      if (caState == State.ENABLED) {
        System.out.println("Enabled Certificate Authority : " + certificateAuthorityName);
      } else {
        System.out.println(
            "Cannot enable the Certificate Authority ! Current CA State: " + caState);
      }
    }
  }
}

Python

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 google.cloud.security.privateca_v1 as privateca_v1

def enable_certificate_authority(
    project_id: str, location: str, ca_pool_name: str, ca_name: str
) -> None:
    """
    Enable the Certificate Authority present in the given ca pool.
    CA cannot be enabled if it has been already deleted.

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

    caServiceClient = privateca_v1.CertificateAuthorityServiceClient()
    ca_path = caServiceClient.certificate_authority_path(
        project_id, location, ca_pool_name, ca_name
    )

    # Create the Enable Certificate Authority Request.
    request = privateca_v1.EnableCertificateAuthorityRequest(
        name=ca_path,
    )

    # Enable the Certificate Authority.
    operation = caServiceClient.enable_certificate_authority(request=request)
    operation.result()

    # Get the current CA state.
    ca_state = caServiceClient.get_certificate_authority(name=ca_path).state

    # Check if the CA is enabled.
    if ca_state == privateca_v1.CertificateAuthority.State.ENABLED:
        print("Enabled Certificate Authority:", ca_name)
    else:
        print("Cannot enable the Certificate Authority ! Current CA State:", ca_state)

REST API

  1. Aktivieren Sie die Zertifizierungsstelle, um Zertifikate aus dem CA-Pool auszustellen.

    HTTP-Methode und URL: 

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

    Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

    Sie sollten in etwa folgende JSON-Antwort erhalten:

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

  2. Fragen Sie den Vorgang ab, bis er abgeschlossen ist.

    HTTP-Methode und URL: 

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

    Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

    Sie sollten in etwa folgende JSON-Antwort erhalten:

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

Zertifizierungsstelle testen

Wenn Sie prüfen möchten, ob eine Zertifizierungsstelle Zertifikate ausstellen kann, fordern Sie ein Zertifikat vom zugehörigen CA-Pool an und geben Sie mit dem Flag --ca explizit den Namen der Zertifizierungsstelle an, die Sie testen möchten.

Mit den folgenden Methoden können Sie ein Zertifikat von einem Zertifizierungsstellenpool anfordern:

  1. Lassen Sie den CA Service einen privaten oder öffentlichen Schlüssel für Sie erstellen.
  2. Generieren Sie Ihren eigenen privaten oder öffentlichen Schlüssel und senden Sie eine Anfrage zur Zertifikatssignierung (Certificate Signing Request, CSR).

Es ist einfacher, einen automatisch generierten privaten oder öffentlichen Schlüssel zu verwenden, um ein Zertifikat von einer Zertifizierungsstelle in einem CA-Pool anzufordern. Dieser Abschnitt enthält Informationen zum Testen einer Zertifizierungsstelle mit dieser Methode.

Führen Sie den folgenden gcloud-Befehl aus, um mit einem automatisch generierten privaten oder öffentlichen Schlüssel ein Zertifikat von einer Zertifizierungsstelle in einem Zertifizierungsstellenpool anzufordern:

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

Ersetzen Sie Folgendes:

  • POOL_ID: Der Name des Zertifizierungsstellenpools.
  • ROOT_CA_ID: Die eindeutige Kennung der Zertifizierungsstelle, die Sie testen möchten.
  • KEY_FILENAME: Die Datei, in die der generierte Schlüssel im PEM-Format geschrieben ist.
  • CERT_FILENAME: Die Datei, in die die resultierende PEM-codierte Zertifikatskettendatei geschrieben wird. Die Zertifikatskette gilt vom Blatt zum Stamm.

  • DNS_NAME: Ein oder mehrere durch Kommas getrennte DNS-Subject Alternative Names (SANs).

    Das Flag --generate-key generiert einen neuen privaten RSA-2048-Schlüssel auf Ihrem Computer.

Wie Sie mit einer Zertifizierungsstelle (Certificate Signing Request, CSR) ein Zertifikat von einer Zertifizierungsstelle in einem Zertifizierungsstellenpool anfordern, oder weitere Informationen zum Anfordern von Zertifikaten finden Sie unter Zertifikat anfordern und ausgestellte Zertifikate ansehen.

Zertifizierungsstellen klonen

Führen Sie den folgenden Befehl aus, um eine vorhandene Zertifizierungsstelle zu klonen oder eine neue Zertifizierungsstelle mit derselben Konfiguration zu erstellen:

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

Ersetzen Sie Folgendes:

  • NEW_CA_ID: Die eindeutige Kennung der neuen Zertifizierungsstelle.
  • POOL_ID: Der Name des Zertifizierungsstellenpools, in dem Sie die neue Zertifizierungsstelle erstellen möchten.

Das Flag --from-ca wird für das Erstellen von Stamm- und untergeordneten Zertifizierungsstellen unterstützt. Die vorhandene Zertifizierungsstelle muss sich im selben Zertifizierungsstellenpool wie die neue Zertifizierungsstelle befinden.

Das Flag --key-algorithm kopiert die gesamte CA-Konfiguration aus der vorhandenen Zertifizierungsstelle (mit Ausnahme der Cloud KMS-Schlüsselversion und des Cloud Storage-Bucket). Sie können jedoch alle Konfigurationswerte in der neuen Zertifizierungsstelle überschreiben, indem Sie das entsprechende Flag explizit angeben. Sie können beispielsweise „--subject SUBJECT“ angeben, um ein neues Subjekt zu verwenden.

Wenn Sie das Flag --key-algorithm weglassen, verwendet der Algorithmus standardmäßig:

  • rsa-pkcs1-4096-sha256 für Root-Zertifizierungsstellen.
  • rsa-pkcs1-2048-sha256 für untergeordnete Zertifizierungsstellen.

Weitere Informationen zu diesem gcloud-Befehl finden Sie unter gcloud privateca roots create.

Nächste Schritte