Root-Zertifizierungsstelle erstellen

Auf dieser Seite wird beschrieben, wie Sie eine Stammzertifizierungsstelle in einem Zertifizierungsstellenpool erstellen.

Eine Stamm-Zertifizierungsstelle steht an der Spitze einer Public-Key-Infrastruktur (PKI) und ist für die Bildung des Trust Anchors der PKI verantwortlich. Um ordnungsgemäß teilzunehmen und Zertifikate in einer PKI verwenden, ein Gerät, eine Software oder eine Komponente muss der PKI vertrauen. Dazu muss das Gerät, die Software oder die Komponente so konfiguriert werden, dass sie der Stammzertifizierungsstelle vertraut. Daher sind alle von der Root-Zertifizierungsstelle ausgestellten Zertifikate vertrauenswürdig.

Hinweise

• Sie benötigen die IAM-Rolle „Operation Manager für CA Service“ (roles/privateca.caManager) oder „CA Service Admin“ (roles/privateca.admin). Weitere Informationen finden Sie unter IAM-Richtlinien konfigurieren.
• Erstellen Sie einen CA-Pool.
• Legen Sie die CA-Einstellungen fest.

Stamm-CA erstellen

Eine Stammzertifizierungsstelle hat ein selbst signiertes Zertifikat, das Sie in den Trust Stores Ihrer Clients verteilen müssen. Das Zertifikat der Stamm-CA befindet sich oben in der Zertifikatskette. Keine andere Zertifizierungsstelle kann das CA-Zertifikat widerrufen. Die CRL der Stamm-CA gilt nur für die anderen Zertifikate, die von der Stamm-CA ausgestellt wurden, nicht für sie selbst.

Console

So erstellen Sie eine Root-CA:

1. Rufen Sie die Seite Certificate Authority Service (Zertifizierungsstelle) in in der Google Cloud Console.

   Zum Certificate Authority Service

2. Klicken Sie auf den Tab CA-Manager.

   Hinweis: Auf dem Tab CA-Manager können Sie nicht mehr als eine Zertifizierungsstelle in einem CA-Pool erstellen.

3. Klicken Sie auf CA erstellen.

CA-Typ auswählen

So konfigurieren Sie die dauerhaften Einstellungen der Zertifizierungsstelle, z. B. Stufe, Speicherort, Lebensdauer und Betriebsstatus bei der Erstellung:

1. Wählen Sie Stamm-CA aus.
2. Geben Sie im Feld Gültig bis die Dauer ein, für die 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 die Region aus, in der Sie den erstellen Sie die Zertifizierungsstelle. Wir empfehlen, die Zertifizierungsstelle in der Nähe von für die Clients Ihrer Anwendung. Weitere Informationen finden Sie unter Das Beste auswählen Standort.

5. Optional: Wählen Sie den Betriebsstatus der zu erstellenden Zertifizierungsstelle aus.

   

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

7. Klicken Sie auf Weiter.

CA-Antragstellernamen konfigurieren

1. Geben Sie im Feld Organisation (O) den Namen Ihres Unternehmens ein.
2. Optional: Geben Sie im Feld Organisationseinheit (OE) die Abteilung oder Geschäftseinheit des Unternehmens ein.
3. Optional: Geben Sie im Feld Ländername einen zweistelligen Ländercode ein.
4. Optional: Geben Sie im Feld Name des Bundeslandes den Namen Ihres Bundeslandes ein.
5. Optional: Geben Sie in das Feld Name des Ortsteils den Namen Ihrer Stadt ein.
6. Geben Sie im Feld Allgemeiner CA-Name (CN) den Namen der Zertifizierungsstelle ein.
7. Geben Sie im Feld Pool-ID den Namen des CA-Pools ein. Sie können die Zertifizierungsstellenpool nach dem Erstellen der Zertifizierungsstelle.
8. Klicken Sie auf Weiter.

Größe und Algorithmus von CA-Schlüsseln konfigurieren

1. Wählen Sie den Algorithmus aus, der Ihren Anforderungen am besten entspricht. Weitere Informationen zur Auswahl des geeigneten Schlüsselalgorithmus finden Sie unter Schlüsselalgorithmus auswählen.
2. Klicken Sie auf Weiter.

CA-Artefakte konfigurieren

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

1. Wählen Sie aus, ob Sie eine von Google oder eine selbstverwaltete Cloud Storage-Bucket.

Wenn Sie keinen selbstverwalteten Cloud Storage-Bucket auswählen, CA Service erstellt einen von Google verwalteten Bucket im selben als Zertifizierungsstelle festlegen.

2. Wählen Sie aus, ob Sie die Veröffentlichung des Zertifikats deaktivieren möchten Sperrlisten (CRLs) und CA-Zertifikate für den Cloud Storage Bucket.

Die Veröffentlichung von CRL und CA-Zertifikat in einem Cloud Storage-Bucket ist standardmäßig aktiviert. Wenn Sie diese Einstellungen deaktivieren möchten, klicken Sie auf die Ein-/Aus-Schaltflächen.

3. Klicken Sie auf 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 Labelwert 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 hinzu, wie in Schritt 2 und 3 beschrieben.
5. Klicken Sie auf Weiter.

Einstellungen überprü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 privateca pools create.

2. Erstellen Sie in dem von Ihnen erstellten CA-Pool eine neue Stamm-CA.

   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 CA-Pools.
   • KEY_ALGORITHM: Der Algorithmus, der zum Erstellen eines Cloud KMS-Schlüssels verwendet werden soll. Dieses Flag ist optional. Wenn Sie dieses Flag nicht angeben, wird der Schlüsselalgorithmus standardmäßig auf rsa-pkcs1-4096-sha256 festgelegt. Für Weitere Informationen finden Sie unter Flag „--key-algorithm“.

   Standardmäßig wird die Zertifizierungsstelle im Status STAGED erstellt. So aktivieren Sie eine Zertifizierungsstelle durch Fügen Sie standardmäßig das Flag --auto-enable ein.

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

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

   gcloud privateca roots create --help
   

Terraform

Verwenden Sie das folgende Beispiel, um eine Root-Zertifizierungsstelle mit einem Schlüssel zu erstellen, der Google gehört und von Google verwaltet wird. Konfiguration:

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 Root-CA mit einem selbst verwalteten 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,
  ]
}

Go

Richten Sie zur Authentifizierung beim CA-Dienst die 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 zur Authentifizierung beim CA-Dienst die 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 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 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 anfordern:

   {
   "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:

   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/certificateAuthorities?certificate_authority_id=ROOT_CA_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/certificateAuthorities?certificate_authority_id=ROOT_CA_ID" | Select-Object -Expand Content

   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:

   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.

   Führen Sie folgenden Befehl aus:

   curl -X GET \
        -H "Authorization: Bearer $(gcloud auth print-access-token)" \
        "https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID"

   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.

   Führen Sie folgenden Befehl aus:

   $cred = gcloud auth print-access-token
   $headers = @{ "Authorization" = "Bearer $cred" }
   
   Invoke-WebRequest `
       -Method GET `
       -Headers $headers `
       -Uri "https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID" | Select-Object -Expand Content

   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": "...",
    }
   }
   

Hinweis: Root-Zertifizierungsstellen werden standardmäßig im Status STAGED erstellt. Wir empfehlen, testen Sie Ihre Zertifizierungsstelle, solange sie sich noch im Status STAGED befindet. Sie müssen Zertifikate direkt von der Zertifizierungsstelle im Status STAGED anfordern, da diese Zertifizierungsstellen keine Zertifikate über das Load Balancing des CA-Pools ausstellen können. Weitere Informationen finden Sie unter Zertifizierungsstelle testen.

Weitere Informationen zu CA-Status finden Sie unter CA-Status.

Nachdem Sie bestätigt haben, dass die Zertifizierungsstelle wie erwartet funktioniert, können Sie sie für folgende Aktionen aktivieren: mit dem Ausstellen von Zertifikaten mit Load-Balancing für den Zertifizierungsstellenpool beginnen.

Hinweis: Wenn Sie Ressourcen wie CA-Pools, Zertifizierungsstellen und Zertifikatsvorlagen erstellen, können Sie davon keine neue Ressource erstellen. mit demselben Namen im selben Projekt und am selben Ort ein.

Stamm-CA aktivieren

gcloud

Führen Sie den folgenden gcloud-Befehl aus, um eine Root-Zertifizierungsstelle 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 im Status STAGED erstellen möchten, legen Sie beim Erstellen der CA das Feld desired_state auf STAGED fest.

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

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

// 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 zur Authentifizierung beim CA-Dienst die 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 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 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:

   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.

   Führen Sie folgenden Befehl aus:

   curl -X POST \
        -H "Authorization: Bearer $(gcloud auth print-access-token)" \
        -H "Content-Type: application/json; charset=utf-8" \
        -d "" \
        "https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificateAuthorities/ROOT_CA_ID:enable"

   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.

   Führen Sie folgenden Befehl aus:

   $cred = gcloud auth print-access-token
   $headers = @{ "Authorization" = "Bearer $cred" }
   
   Invoke-WebRequest `
       -Method POST `
       -Headers $headers `
       -Uri "https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificateAuthorities/ROOT_CA_ID:enable" | Select-Object -Expand Content

   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:

   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.

   Führen Sie folgenden Befehl aus:

   curl -X GET \
        -H "Authorization: Bearer $(gcloud auth print-access-token)" \
        "https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID"

   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.

   Führen Sie folgenden Befehl aus:

   $cred = gcloud auth print-access-token
   $headers = @{ "Authorization" = "Bearer $cred" }
   
   Invoke-WebRequest `
       -Method GET `
       -Headers $headers `
       -Uri "https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/operations/operation-UUID" | Select-Object -Expand Content

   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": "...",
    }
   }
   

Achtung: Alle Zertifikate, die mit dem privaten Schlüssel der Stamm-CA signiert sind, werden von Browsern weithin als vertrauenswürdig eingestuft. Wir empfehlen, keine Zertifikate für die Endentität auszustellen von einer Stammzertifizierungsstelle. Erstellen Sie untergeordnete Zertifizierungsstellen, um Zertifikate der Endentität auszustellen.

Zertifizierungsstelle testen

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

Sie können mit den folgenden Methoden ein Zertifikat von einem CA-Pool anfordern:

1. Lassen Sie einen privaten oder öffentlichen Schlüssel vom CA-Dienst 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, mit einem automatisch generierten privaten Schlüssel oder öffentlichen Schlüssel eine Zertifikat von einer Zertifizierungsstelle in einem CA-Pool. Dieser Abschnitt enthält Informationen zum Testen einer Zertifizierungsstelle mit dieser Methode.

Wenn Sie einen automatisch generierten privaten oder öffentlichen Schlüssel verwenden möchten, um ein Zertifikat von einer Zertifizierungsstelle in einem CA-Pool anzufordern, führen Sie den folgenden gcloud-Befehl aus:

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 CA-Pools.
• ROOT_CA_ID: Die eindeutige Kennung der Zertifizierungsstelle, die Sie testen möchten.
• KEY_FILENAME: Die Datei, in der der generierte Schlüssel im PEM-Format geschrieben wird.
• CERT_FILENAME: Die Datei, in die die resultierende PEM-codierte Zertifikatkettendatei geschrieben wird. Die Zertifikatskette ist in der Reihenfolge vom Blatt bis zum Stamm angeordnet.

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

  Mit dem Flag --generate-key wird auf Ihrem Computer ein neuer privater RSA-2048-Schlüssel generiert.

So fordern Sie mit einer Anfrage zur Zertifikatssignierung (Certificate Signing Request, CSR) ein Zertifikat von einer Zertifizierungsstelle in einem CA-Pool 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, um sie zu erneuern, oder um 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 CA-Pools, in dem Sie die neue Zertifizierungsstelle erstellen möchten.

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

Das Flag --key-algorithm kopiert die gesamte CA-Konfiguration von der vorhandenen Zertifizierungsstelle (außer die Cloud KMS-Schlüsselversion und den Cloud Storage-Bucket). Sie können jedoch weiterhin alle Konfigurationswerte in der neuen Zertifizierungsstelle überschreiben, indem Sie das entsprechende Flag explizit angeben. Sie können beispielsweise weiterhin `--subject SUBJECT angeben, um ein neues Betrefffeld zu verwenden.

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

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

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

Nächste Schritte

• Weitere Informationen zum Erstellen einer untergeordneten Zertifizierungsstelle
• Informationen zum Anfordern von Zertifikaten
• Weitere Informationen zu Vorlagen und Richtlinien für die Ausstellung