Root-Zertifizierungsstelle erstellen

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

Eine Stamm-CA befindet sich an oberster Stelle der PKI-Hierarchie (Public Key Infrastructure) und ist ist für das Erstellen des Vertrauensankers der PKI verantwortlich. Um ordnungsgemäß teilzunehmen und Sie verwenden Zertifikate in einer PKI, einem Gerät, einer Software oder einer Komponente, die der PKI vertrauen muss. Dazu muss das Gerät, die Software oder die Komponente so konfiguriert werden, dass sie der Stammzertifizierungsstelle vertraut. Daher sind alle von der Stammzertifizierungsstelle ausgestellten Zertifikate vertrauenswürdig.

Hinweise

• Prüfen Sie, ob CA Service Operation Manager installiert ist (roles/privateca.caManager) oder den CA Service-Administrator (roles/privateca.admin) IAM-Rolle. Weitere Informationen finden Sie unter Konfigurieren Sie IAM-Richtlinien.
• Erstellen Sie einen CA-Pool.
• Legen Sie die CA-Einstellungen fest.

Stamm-CA erstellen

Eine Stammzertifizierungsstelle hat ein selbst signiertes Zertifikat, das Sie an die Vertrauensstellung verteilen müssen der Geschäfte Ihrer Kundschaft. Das Zertifikat der Stammzertifizierungsstelle befindet sich oben auf der Zertifikatskette Keine andere Zertifizierungsstelle kann das CA-Zertifikat widerrufen. Die Zertifikatssperrliste des gilt nur für die anderen Zertifikate, die sie ausgestellt hat, nicht für selbst.

Console

So erstellen Sie eine Root-Zertifizierungsstelle:

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: Sie können mit dem Parameter CA-Manager
   .

3. Klicken Sie auf CA erstellen.

CA-Typ auswählen

Zum Konfigurieren der permanenten Einstellungen der Zertifizierungsstelle, z. B. Stufe, Standort, die Lebensdauer und den Betriebsstatus bei der Erstellung:

1. Wählen Sie Root-Zertifizierungsstelle aus.
2. Geben Sie im Feld Gültig für die Dauer ein, für die das Ereignis Zertifikate, die vom CA-Zertifikat ausgestellt wurden, sind gültig.
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 aus der Liste die das dem Zertifikatstyp entspricht, den Sie Ausstellende Zertifizierungsstelle.

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) das Unternehmen ein. oder Geschäftseinheit.
3. Optional: Geben Sie im Feld Ländername einen aus zwei Buchstaben bestehenden Ländercode ein.
4. Optional: Geben Sie im Feld Name des Bundesstaats oder der Provinz den Namen des Bundesstaats oder der Provinz ein. Ihres Bundesstaats.
5. Optional: Geben Sie in das Feld Name des Ortsteils den Namen Ihrer Stadt ein.
6. Geben Sie im 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 die Zertifizierungsstellenpool nach dem Erstellen der Zertifizierungsstelle.
8. Klicken Sie auf Weiter.

Größe des CA-Schlüssels und Algorithmus konfigurieren

1. Wählen Sie den Schlüsselalgorithmus 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.

Veröffentlichung von Zertifikatssperrlisten und CA-Zertifikaten 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 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 Schlüssel und Wert ein, wie in den Schritten 2 und 3 erwähnt.
5. Klicken Sie auf 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 Zertifizierungsstelle erstellen Pool hinzu.

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

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

   Standardmäßig wird die Zertifizierungsstelle mit dem 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 für CA-Zertifikate und Zertifikatssperrlisten werden veröffentlicht, --bucket bucket-name hinzufügen zum Befehl hinzu. Ersetzen Sie bucket-name durch den Name 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 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 das folgende Beispiel, um eine Root-Zertifizierungsstelle mit einem selbstverwalteten Schlüssel zu erstellen Konfiguration:

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 Standardanmeldedaten für Anwendungen ein, um sich bei CA Service zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import (
	"context"
	"fmt"
	"io"

	privateca "cloud.google.com/go/security/privateca/apiv1"
	"cloud.google.com/go/security/privateca/apiv1/privatecapb"
	"google.golang.org/protobuf/types/known/durationpb"
)

// Create 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 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 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 diese direkt Fordern Sie Zertifikate vom Status der Zertifizierungsstelle STAGED an, da diese Zertifizierungsstellen keine über das Load-Balancing des CA-Pools. Weitere Informationen finden Sie unter CA testen.

Weitere Informationen zu CA-Bundesstaaten finden Sie unter CA-Bundesstaaten

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.

Root-Zertifizierungsstelle 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. Zum Erstellen einer Root-Zertifizierungsstelle mit dem Status STAGED legen Sie Folgendes fest: das Feld desired_state beim Erstellen der Zertifizierungsstelle auf STAGED.

Sie können das Feld desired_state nach der CA-Erstellung auf ENABLED oder DISABLED setzen.

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 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 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: Jedes mit dem privaten Schlüssel der Stammzertifizierungsstelle signierte Zertifikat ist weit verbreitet als vertrauenswürdig eingestuft werden. 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.

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

1. Lassen Sie 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, 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 eine Zertifizierungsstelle mit dieser Methode testen.

So fordern Sie ein Zertifikat mit einem automatisch generierten privaten oder öffentlichen Schlüssel an: Führen Sie von einer Zertifizierungsstelle in einem Zertifizierungsstellenpool 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 Zertifizierungsstellenpools.
• 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 vom Blatt zum Stamm angeordnet.

• 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.

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

Sie können eine vorhandene Zertifizierungsstelle klonen, um diese Zertifizierungsstelle zu verlängern, oder eine neue Zertifizierungsstelle mit derselben Zertifizierungsstelle erstellen. Konfiguration enthält, führen Sie den folgenden Befehl aus:

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 den Zugriff wünschen. um die neue Zertifizierungsstelle zu erstellen.

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

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 Sie können trotzdem alle Konfigurationswerte in der neuen Zertifizierungsstelle überschreiben, explizit das entsprechende Flag an. Sie können zum Beispiel immer noch Geben Sie `--subject SUBJECT an, um einen neuen Betreff zu verwenden.

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

• 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 privatecaroots create verwenden.

Nächste Schritte

• Weitere Informationen zum Erstellen einer untergeordneten Zertifizierungsstelle
• Informationen zum Anfordern von Zertifikaten
• Vorlagen und Ausstellungsrichtlinien