Halaman ini diterjemahkan oleh Cloud Translation API.

Meminta sertifikat

Halaman ini menjelaskan cara membuat permintaan sertifikat di Certificate Authority Service.

Anda dapat meminta sertifikat menggunakan metode berikut:

Buat kunci pribadi atau publik Anda sendiri dan kirimkan Permintaan Penandatanganan Sertifikat (CSR).
Gunakan kunci pribadi atau publik yang dibuat otomatis oleh Layanan CA.
Menggunakan kunci Cloud Key Management Service (Cloud KMS) yang ada.

Sebelum memulai

Menyiapkan lingkungan Anda untuk Layanan CA.
Untuk mendapatkan izin yang diperlukan guna menerbitkan sertifikat, minta administrator untuk memberi Anda peran IAM CA Service Certificate Requester (roles/privateca.certificateRequester) atau CA Service Certificate Manager (roles/privateca.certificateManager).

Untuk mengetahui informasi selengkapnya tentang peran IAM bawaan untuk Layanan CA, lihat Kontrol akses dengan IAM.

Untuk mengetahui informasi tentang cara memberikan peran IAM kepada akun utama, lihat Memberikan satu peran.

Meminta sertifikat menggunakan CSR

Untuk mendapatkan sertifikat, Anda membuat CSR, yang kemudian digunakan untuk meminta sertifikat.

Membuat CSR

Untuk petunjuk mendetail tentang cara membuat CSR menggunakan OpenSSL, lihat Cara membuat CSR dengan OpenSSL. Anda juga dapat menggunakan contoh file konfigurasi berikut sebagai referensi saat membuat CSR.

Untuk menggunakan contoh file konfigurasi, ikuti langkah-langkah berikut:

Buat file konfigurasi bernama csr.cnf menggunakan konfigurasi berikut.
```
cat << EOF > csr.cnf
[req]
distinguished_name = req_distinguished_name
req_extensions = v3_req
prompt = no

[req_distinguished_name]
CN = example.com

[v3_req]
keyUsage = critical, digitalSignature, keyEncipherment
extendedKeyUsage = serverAuth
subjectAltName = @alt_names

[alt_names]
DNS.1 = example.com
DNS.2 = www.example.com
EOF
```
Contoh ini menghasilkan kunci RSA 2048-bit (diekripsi dengan frasa sandi) dan CSR yang sesuai yang berisi hal berikut:
- atribut commonName di DN subjek
- ekstensi subjectAlternativeName
- ekstensi keyUsage (ditandai sebagai penting)
- ekstensi extendedKeyUsage
Ubah parameter sesuai kebutuhan. Untuk menggunakan format file konfigurasi x509v3_config guna menentukan ekstensi untuk sertifikat X.509 dan CSR, lihat dokumentasi OpenSSL.
Jalankan perintah openssl berikut untuk membuat CSR dan kunci pribadi yang sesuai:
```
openssl req -newkey rsa:2048 -out csr.pem -keyout key.pem -config csr.cnf
```
Perintah ini akan menghasilkan file berikut:
- csr.pem: CSR Anda, siap dikirim ke CA
- key.pem: kunci pribadi Anda, yang harus Anda jaga keamanannya
Gunakan file csr.pem dalam permintaan sertifikat Anda.

Mengirim permintaan sertifikat menggunakan CSR

Untuk meminta sertifikat menggunakan CSR, ikuti langkah-langkah berikut:

Konsol

Buka halaman Certificate Authority Service di konsol Google Cloud.

Buka Certificate Authority Service
Klik Minta sertifikat.
Pilih wilayah. Region harus sama dengan region kumpulan CA yang ingin Anda gunakan.
Pilih kumpulan CA.
Opsional: Pilih CA tertentu dari kumpulan CA. Perhatikan bahwa saat memilih CA tertentu untuk penerbitan sertifikat, Anda akan membuat dependensi pada CA tersebut, sehingga lebih sulit untuk memutar CA.
Opsional: Pilih template sertifikat. Jika Anda menggunakan template sertifikat, pastikan kebijakan template sertifikat tidak bertentangan dengan kebijakan kumpulan CA yang dipilih.
Klik Berikan Permintaan Penandatanganan Sertifikat (CSR), lalu klik Berikutnya. Detail sertifikat akan ditampilkan.
Opsional: Untuk menimpa nama sertifikat yang dibuat secara otomatis, masukkan nama kustom di kolom Nama sertifikat. Setelah sertifikat dibuat, Anda tidak dapat menghapus atau menggunakan kembali nama sertifikat.
Opsional: Untuk memilih periode validitas kustom untuk sertifikat, masukkan nilai di kolom Valid for.
Salin dan tempel CSR Anda di kotak CSR Sertifikat. Jika Anda ingin mengupload file yang berisi CSR, klik Jelajahi, lalu pilih file Anda.
Klik Buat sertifikat.

Mendownload sertifikat yang ditandatangani

Untuk melihat sertifikat yang dihasilkan, klik Lihat sertifikat, lalu klik Lihat.
Untuk menyalin sertifikat, klik . Untuk mendownload sertifikat dalam bentuk file .crt, klik Download certificate.
Opsional: Untuk mendownload rantai sertifikat, klik Download certificate chain.

gcloud

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

Ganti kode berikut:

CERT_ID: ID unik sertifikat.
POOL_ID: Nama kumpulan CA.
CSR_FILENAME: File yang menyimpan CSR yang dienkode PEM.

Flag --validity menentukan durasi sertifikat berlaku. Ini adalah flag opsional yang nilai defaultnya adalah 30 hari.

Untuk informasi selengkapnya tentang perintah gcloud privateca certificates create, lihat gcloud privateca certificates create.

Terraform

resource "google_privateca_certificate_authority" "test_ca" {
  pool                     = "my-pool"
  certificate_authority_id = "my-certificate-authority"
  location                 = "us-central1"
  deletion_protection      = false # set to true to prevent destruction of the resource
  config {
    subject_config {
      subject {
        organization = "HashiCorp"
        common_name  = "my-certificate-authority"
      }
      subject_alt_name {
        dns_names = ["hashicorp.com"]
      }
    }
    x509_config {
      ca_options {
        # is_ca *MUST* be true for certificate authorities
        is_ca = true
      }
      key_usage {
        base_key_usage {
          # cert_sign and crl_sign *MUST* be true for certificate authorities
          cert_sign = true
          crl_sign  = true
        }
        extended_key_usage {
          server_auth = false
        }
      }
    }
  }
  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
}


resource "google_privateca_certificate" "default" {
  pool                  = "my-pool"
  location              = "us-central1"
  certificate_authority = google_privateca_certificate_authority.test_ca.certificate_authority_id
  lifetime              = "860s"
  name                  = "my-certificate"
  pem_csr               = tls_cert_request.example.cert_request_pem
}

resource "tls_private_key" "example" {
  algorithm = "RSA"
}

resource "tls_cert_request" "example" {
  private_key_pem = tls_private_key.example.private_key_pem

  subject {
    common_name  = "example.com"
    organization = "ACME Examples, Inc"
  }
}

REST API

Buat Permintaan Penandatanganan Sertifikat (CSR) menggunakan metode pilihan Anda, seperti openssl.

Berikut adalah contoh CSR yang dienkode untuk JSON.

Minta sertifikat.

Metode HTTP dan URL:

POST https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificates?certificate_id=CERTIFICATE_ID

Meminta isi JSON:

{
 "lifetime": {
   "seconds": 3600,
   "nanos": 0
 },
 "pem_csr": "PEM_CSR"
}

Untuk mengirim permintaan Anda, perluas salah satu opsi berikut:

curl (Linux, macOS, atau Cloud Shell)

Catatan: Perintah berikut mengasumsikan bahwa Anda telah login ke gcloud CLI dengan akun pengguna Anda dengan menjalankan gcloud init atau gcloud auth login , atau dengan menggunakan Cloud Shell, yang secara otomatis membuat Anda login ke gcloud CLI . Anda dapat memeriksa akun yang saat ini aktif dengan menjalankan gcloud auth list.

Simpan isi permintaan dalam file bernama request.json, dan jalankan perintah berikut:

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

PowerShell (Windows)

Catatan: Perintah berikut mengasumsikan bahwa Anda telah login ke gcloud CLI dengan akun pengguna Anda dengan menjalankan gcloud init atau gcloud auth login . Anda dapat memeriksa akun yang saat ini aktif dengan menjalankan gcloud auth list.

Simpan isi permintaan dalam file bernama request.json, dan jalankan perintah berikut:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificates?certificate_id=CERTIFICATE_ID" | Select-Object -Expand Content

Anda akan melihat respons JSON seperti berikut:

{
 "name": "projects/project-id/locations/location/certificateAuthorities/ca-id/certificates/certificate-id",
 "pemCertificate": "-----BEGIN CERTIFICATE-----...",
 "certificateDescription": {...}
}

Meminta sertifikat menggunakan kunci yang dibuat secara otomatis

Konsol

Anda dapat menggunakan Konsol Google Cloud untuk membuat sertifikat TLS klien atau server.

Buka halaman Certificate Authority Service di konsol Google Cloud.

Buka Certificate Authority Service
Klik Minta sertifikat.
Pilih wilayah. Region harus sama dengan region kumpulan CA yang ingin Anda gunakan.
Pilih kumpulan CA.
Klik Masukkan detail secara manual. Detail sertifikat akan ditampilkan.
Opsional: Ganti Nama sertifikat yang dibuat otomatis dengan nama kustom yang unik.
Opsional: Untuk memilih periode validitas kustom untuk sertifikat, masukkan nilai di kolom Valid for.

Menambahkan nama domain

Di bagian Tambahkan nama domain, masukkan nama domain di kolom Nama domain 1.
Opsional: Jika Anda ingin menambahkan lebih dari satu nama domain, klik Tambahkan item, lalu masukkan nama domain lain di kolom Domain name 2.

Penggunaan kunci yang diperpanjang

Opsional: Di bagian Extended key usage, pilih antara opsi berikut berdasarkan kasus penggunaan Anda:
- TLS Klien: Sertifikat ini memungkinkan Anda mengautentikasi identitas peminta.
- TLS Server: Sertifikat ini memungkinkan Anda mengautentikasi identitas server.
Klik Berikutnya.

Mengonfigurasi ukuran dan algoritma kunci

Opsional: Di bagian Configure key size and algorithm, pilih ukuran dan algoritma kunci tanda tangan dari daftar. Jika Anda melewati langkah ini, kunci RSASSA-PSS 2048 bit dengan ringkasan SHA 256 akan digunakan. Untuk informasi cara memilih kunci dan algoritma penandatanganan, lihat Memilih algoritma kunci.
Klik Buat sertifikat.

Mendownload sertifikat yang ditandatangani

Untuk melihat sertifikat yang dihasilkan, klik Lihat sertifikat, lalu klik Lihat.
Opsional: Untuk mendownload rantai sertifikat berenkode PEM, klik Download rantai sertifikat.
Opsional: Untuk mendownload kunci pribadi berenkode PEM yang terkait, klik Download kunci pribadi.

Penting: Anda tidak dapat mengambil kunci ini setelah keluar dari halaman ini. Kunci ini bersifat sensitif. Sebaiknya lindungi kunci di lokasi yang aman.
Penting: Jika Anda menggunakan kumpulan CA DevOps, ini adalah satu-satunya waktu Anda dapat mendownload sertifikat yang dibuat. Layanan CA tidak menyimpan konten sertifikat setelah layar ini.

gcloud

Untuk menggunakan fitur kunci yang dibuat otomatis, Anda harus menginstal library Python Cryptographic Authority (PyCA). Untuk petunjuk tentang cara menginstal library kriptografi Pyca, lihat Menyertakan library kriptografi Pyca.

Untuk membuat sertifikat, gunakan perintah gcloud berikut:

gcloud privateca certificates create \
  --issuer-pool POOL_ID \
  --generate-key \
  --key-output-file KEY_FILENAME \
  --cert-output-file CERT_FILENAME \
  --dns-san "DNS_NAME" \
  --use-preset-profile "CERTIFICATE_PROFILE"

Ganti kode berikut:

POOL_ID: Nama kumpulan CA.
KEY_FILENAME: Jalur tempat file kunci pribadi yang dihasilkan harus ditulis.
CERT_FILENAME: Jalur tempat file rantai sertifikat yang dienkode PEM harus ditulis. Rantai sertifikat diurutkan dari entitas akhir ke root.
DNS_NAME: Satu atau beberapa nama alternatif subjek (SAN) DNS yang dipisahkan koma.
CERTIFICATE_PROFILE: ID unik profil sertifikat. Misalnya, gunakan leaf_server_tls untuk TLS server entitas akhir.

Perintah gcloud menyebutkan flag berikut:

--generate-key: Membuat kunci pribadi RSA-2048 baru di komputer Anda.

Anda juga dapat menggunakan kombinasi flag berikut:

--dns-san: Memungkinkan Anda meneruskan satu atau beberapa SAN DNS yang dipisahkan koma.
--ip-san: Memungkinkan Anda meneruskan satu atau beberapa SAN IP yang dipisahkan koma.
--uri-san: Memungkinkan Anda meneruskan satu atau beberapa SAN URI yang dipisahkan koma.
--subject: Memungkinkan Anda meneruskan nama X.501 subjek sertifikat.

Untuk informasi selengkapnya tentang perintah gcloud privateca certificates create, lihat gcloud privateca certificates create.

Go

Untuk melakukan autentikasi ke Layanan CA, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

import (
	"context"
	"fmt"
	"io"

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

// Create a Certificate which is issued by the Certificate Authority present in the CA Pool.
// The key used to sign the certificate is created by the Cloud KMS.
func createCertificate(
	w io.Writer,
	projectId string,
	location string,
	caPoolId string,
	caId string,
	certId string,
	commonName string,
	domainName string,
	certDuration int64,
	publicKeyBytes []byte) error {
	// projectId := "your_project_id"
	// location := "us-central1"		// For a list of locations, see: https://cloud.google.com/certificate-authority-service/docs/locations.
	// caPoolId := "ca-pool-id"			// The CA Pool id in which the certificate authority exists.
	// caId := "ca-id"					// The name of the certificate authority which issues the certificate.
	// certId := "certificate"			// A unique name for the certificate.
	// commonName := "cert-name"		// A common name for the certificate.
	// domainName := "cert.example.com"	// Fully qualified domain name for the certificate.
	// certDuration := int64(31536000)	// The validity of the certificate in seconds.
	// publicKeyBytes 					// The public key used in signing the certificates.

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

	// Set the Public Key and its format.
	publicKey := &privatecapb.PublicKey{
		Key:    publicKeyBytes,
		Format: privatecapb.PublicKey_PEM,
	}

	// Set Certificate subject config.
	subjectConfig := &privatecapb.CertificateConfig_SubjectConfig{
		Subject: &privatecapb.Subject{
			CommonName: commonName,
		},
		SubjectAltName: &privatecapb.SubjectAltNames{
			DnsNames: []string{domainName},
		},
	}

	// Set the X.509 fields required for the certificate.
	x509Parameters := &privatecapb.X509Parameters{
		KeyUsage: &privatecapb.KeyUsage{
			BaseKeyUsage: &privatecapb.KeyUsage_KeyUsageOptions{
				DigitalSignature: true,
				KeyEncipherment:  true,
			},
			ExtendedKeyUsage: &privatecapb.KeyUsage_ExtendedKeyUsageOptions{
				ServerAuth: true,
				ClientAuth: true,
			},
		},
	}

	// Set certificate settings.
	cert := &privatecapb.Certificate{
		CertificateConfig: &privatecapb.Certificate_Config{
			Config: &privatecapb.CertificateConfig{
				PublicKey:     publicKey,
				SubjectConfig: subjectConfig,
				X509Config:    x509Parameters,
			},
		},
		Lifetime: &durationpb.Duration{
			Seconds: certDuration,
		},
	}

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

	// Create the CreateCertificateRequest.
	// See https://pkg.go.dev/cloud.google.com/go/security/privateca/apiv1/privatecapb#CreateCertificateRequest.
	req := &privatecapb.CreateCertificateRequest{
		Parent:                        fullCaPoolName,
		CertificateId:                 certId,
		Certificate:                   cert,
		IssuingCertificateAuthorityId: caId,
	}

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

	fmt.Fprintf(w, "Certificate %s created", certId)

	return nil
}

Java

Untuk melakukan autentikasi ke Layanan CA, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.


import com.google.api.core.ApiFuture;
import com.google.cloud.security.privateca.v1.CaPoolName;
import com.google.cloud.security.privateca.v1.Certificate;
import com.google.cloud.security.privateca.v1.CertificateAuthorityServiceClient;
import com.google.cloud.security.privateca.v1.CertificateConfig;
import com.google.cloud.security.privateca.v1.CertificateConfig.SubjectConfig;
import com.google.cloud.security.privateca.v1.CreateCertificateRequest;
import com.google.cloud.security.privateca.v1.KeyUsage;
import com.google.cloud.security.privateca.v1.KeyUsage.ExtendedKeyUsageOptions;
import com.google.cloud.security.privateca.v1.KeyUsage.KeyUsageOptions;
import com.google.cloud.security.privateca.v1.PublicKey;
import com.google.cloud.security.privateca.v1.PublicKey.KeyFormat;
import com.google.cloud.security.privateca.v1.Subject;
import com.google.cloud.security.privateca.v1.SubjectAltNames;
import com.google.cloud.security.privateca.v1.X509Parameters;
import com.google.cloud.security.privateca.v1.X509Parameters.CaOptions;
import com.google.protobuf.ByteString;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class CreateCertificate {

  public static void main(String[] args)
      throws InterruptedException, ExecutionException, IOException {
    // TODO(developer): Replace these variables before running the sample.

    // publicKeyBytes: Public key used in signing the certificates.
    // location: For a list of locations, see:
    // https://cloud.google.com/certificate-authority-service/docs/locations
    // poolId: Set a unique id for the CA pool.
    // certificateAuthorityName: The name of the certificate authority which issues the certificate.
    // certificateName: Set a unique name for the certificate.
    String project = "your-project-id";
    ByteString publicKeyBytes = ByteString.copyFrom(new byte[]{});
    String location = "ca-location";
    String poolId = "ca-poolId";
    String certificateAuthorityName = "certificate-authority-name";
    String certificateName = "certificate-name";

    createCertificate(
        project, location, poolId, certificateAuthorityName, certificateName, publicKeyBytes);
  }

  // Create a Certificate which is issued by the Certificate Authority present in the CA Pool.
  // The public key used to sign the certificate can be generated using any crypto
  // library/framework.
  public static void createCertificate(
      String project,
      String location,
      String poolId,
      String certificateAuthorityName,
      String certificateName,
      ByteString publicKeyBytes)
      throws InterruptedException, ExecutionException, IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `certificateAuthorityServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (CertificateAuthorityServiceClient certificateAuthorityServiceClient =
        CertificateAuthorityServiceClient.create()) {

      // commonName: Enter a title for your certificate.
      // orgName: Provide the name of your company.
      // domainName: List the fully qualified domain name.
      // certificateLifetime: The validity of the certificate in seconds.
      String commonName = "commonname";
      String orgName = "orgname";
      String domainName = "dns.example.com";
      long certificateLifetime = 1000L;

      // Set the Public Key and its format.
      PublicKey publicKey =
          PublicKey.newBuilder().setKey(publicKeyBytes).setFormat(KeyFormat.PEM).build();

      SubjectConfig subjectConfig =
          SubjectConfig.newBuilder()
              // Set the common name and org name.
              .setSubject(
                  Subject.newBuilder().setCommonName(commonName).setOrganization(orgName).build())
              // Set the fully qualified domain name.
              .setSubjectAltName(SubjectAltNames.newBuilder().addDnsNames(domainName).build())
              .build();

      // Set the X.509 fields required for the certificate.
      X509Parameters x509Parameters =
          X509Parameters.newBuilder()
              .setKeyUsage(
                  KeyUsage.newBuilder()
                      .setBaseKeyUsage(
                          KeyUsageOptions.newBuilder()
                              .setDigitalSignature(true)
                              .setKeyEncipherment(true)
                              .setCertSign(true)
                              .build())
                      .setExtendedKeyUsage(
                          ExtendedKeyUsageOptions.newBuilder().setServerAuth(true).build())
                      .build())
              .setCaOptions(CaOptions.newBuilder().setIsCa(true).buildPartial())
              .build();

      // Create certificate.
      Certificate certificate =
          Certificate.newBuilder()
              .setConfig(
                  CertificateConfig.newBuilder()
                      .setPublicKey(publicKey)
                      .setSubjectConfig(subjectConfig)
                      .setX509Config(x509Parameters)
                      .build())
              .setLifetime(Duration.newBuilder().setSeconds(certificateLifetime).build())
              .build();

      // Create the Certificate Request.
      CreateCertificateRequest certificateRequest =
          CreateCertificateRequest.newBuilder()
              .setParent(CaPoolName.of(project, location, poolId).toString())
              .setCertificateId(certificateName)
              .setCertificate(certificate)
              .setIssuingCertificateAuthorityId(certificateAuthorityName)
              .build();

      // Get the Certificate response.
      ApiFuture<Certificate> future =
          certificateAuthorityServiceClient
              .createCertificateCallable()
              .futureCall(certificateRequest);

      Certificate response = future.get();
      // Get the PEM encoded, signed X.509 certificate.
      System.out.println(response.getPemCertificate());
      // To verify the obtained certificate, use this intermediate chain list.
      System.out.println(response.getPemCertificateChainList());
    }
  }
}

Python

Untuk melakukan autentikasi ke Layanan CA, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

import google.cloud.security.privateca_v1 as privateca_v1
from google.protobuf import duration_pb2


def create_certificate(
    project_id: str,
    location: str,
    ca_pool_name: str,
    ca_name: str,
    certificate_name: str,
    common_name: str,
    domain_name: str,
    certificate_lifetime: int,
    public_key_bytes: bytes,
) -> None:
    """
    Create a Certificate which is issued by the Certificate Authority present in the CA Pool.
    The key used to sign the certificate is created by the Cloud KMS.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        location: location you want to use. For a list of locations, see: https://cloud.google.com/certificate-authority-service/docs/locations.
        ca_pool_name: set a unique name for the CA pool.
        ca_name: the name of the certificate authority which issues the certificate.
        certificate_name: set a unique name for the certificate.
        common_name: a title for your certificate.
        domain_name: fully qualified domain name for your certificate.
        certificate_lifetime: the validity of the certificate in seconds.
        public_key_bytes: public key used in signing the certificates.
    """

    caServiceClient = privateca_v1.CertificateAuthorityServiceClient()

    # The public key used to sign the certificate can be generated using any crypto library/framework.
    # Also you can use Cloud KMS to retrieve an already created public key.
    # For more info, see: https://cloud.google.com/kms/docs/retrieve-public-key.

    # Set the Public Key and its format.
    public_key = privateca_v1.PublicKey(
        key=public_key_bytes,
        format_=privateca_v1.PublicKey.KeyFormat.PEM,
    )

    subject_config = privateca_v1.CertificateConfig.SubjectConfig(
        subject=privateca_v1.Subject(common_name=common_name),
        subject_alt_name=privateca_v1.SubjectAltNames(dns_names=[domain_name]),
    )

    # Set the X.509 fields required for the certificate.
    x509_parameters = privateca_v1.X509Parameters(
        key_usage=privateca_v1.KeyUsage(
            base_key_usage=privateca_v1.KeyUsage.KeyUsageOptions(
                digital_signature=True,
                key_encipherment=True,
            ),
            extended_key_usage=privateca_v1.KeyUsage.ExtendedKeyUsageOptions(
                server_auth=True,
                client_auth=True,
            ),
        ),
    )

    # Create certificate.
    certificate = privateca_v1.Certificate(
        config=privateca_v1.CertificateConfig(
            public_key=public_key,
            subject_config=subject_config,
            x509_config=x509_parameters,
        ),
        lifetime=duration_pb2.Duration(seconds=certificate_lifetime),
    )

    # Create the Certificate Request.
    request = privateca_v1.CreateCertificateRequest(
        parent=caServiceClient.ca_pool_path(project_id, location, ca_pool_name),
        certificate_id=certificate_name,
        certificate=certificate,
        issuing_certificate_authority_id=ca_name,
    )
    result = caServiceClient.create_certificate(request=request)

    print("Certificate creation result:", result)

Meminta sertifikat menggunakan kunci Cloud KMS yang ada

Anda hanya dapat menggunakan Google Cloud CLI untuk meminta sertifikat menggunakan kunci Cloud KMS.

gcloud

Untuk menggunakan kunci Cloud KMS guna membuat sertifikat TLS server entitas akhir, jalankan perintah berikut:

gcloud privateca certificates create \
  --issuer-pool POOL_ID \
  --kms-key-version projects/PROJECT_ID/locations/LOCATION_ID/keyRings/KEY_RING/cryptoKeys/KEY/cryptoKeyVersions/KEY_VERSION \
  --cert-output-file CERT_FILENAME \
  --dns-san "DNS_NAME" \
  --use-preset-profile "leaf_server_tls"

Ganti kode berikut:

POOL_ID: Nama kumpulan CA.
PROJECT_ID: Project ID.
LOCATION_ID: Lokasi key ring.
KEY_RING: Nama key ring tempat kunci berada.
KEY: Nama kunci.
KEY_VERSION: Versi kunci.
CERT_FILENAME: Jalur file rantai sertifikat yang dienkode PEM. File rantai sertifikat diurutkan dari entitas akhir ke root.
DNS_NAME: SAN DNS yang dipisahkan koma.

Menerbitkan sertifikat dari CA tertentu dalam kumpulan CA

Bagian ini menjelaskan cara menerbitkan sertifikat dari CA tertentu dalam kumpulan CA.

Konsol

Buka halaman Certificate Authority Service di konsol Google Cloud.

Buka Certificate Authority Service
Klik Minta sertifikat.
Pilih wilayah. Region harus sama dengan region kumpulan CA yang ingin Anda gunakan.
Pilih kumpulan CA.
Untuk memilih CA, klik Gunakan CA tertentu dari kumpulan CA ini, lalu pilih CA dari daftar.
Pilih parameter lain seperti yang Anda lakukan di bagian Meminta sertifikat menggunakan Kunci yang dibuat secara otomatis atau bagian Meminta sertifikat menggunakan CSR.

gcloud

Untuk menargetkan CA tertentu dalam kumpulan CA untuk penerbitan sertifikat, tambahkan tanda --ca dengan CA_ID CA yang harus menerbitkan sertifikat.

gcloud privateca certificates create \
  --issuer-pool POOL_ID \
  --ca CA_ID \
  --generate-key \
  --key-output-file KEY_FILENAME \
  --cert-output-file CERT_FILENAME \
  --dns-san "DNS_NAME" \
  --use-preset-profile "leaf_server_tls"

Terraform

resource "google_privateca_certificate_authority" "authority" {
  // This example assumes this pool already exists.
  // Pools cannot be deleted in normal test circumstances, so we depend on static pools
  pool                     = "my-pool"
  certificate_authority_id = "my-sample-certificate-authority"
  location                 = "us-central1"
  deletion_protection      = false # set to true to prevent destruction of the resource
  config {
    subject_config {
      subject {
        organization = "HashiCorp"
        common_name  = "my-certificate-authority"
      }
      subject_alt_name {
        dns_names = ["hashicorp.com"]
      }
    }
    x509_config {
      ca_options {
        is_ca = true
      }
      key_usage {
        base_key_usage {
          digital_signature = true
          cert_sign         = true
          crl_sign          = true
        }
        extended_key_usage {
          server_auth = true
        }
      }
    }
  }
  lifetime = "86400s"
  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
}


resource "google_privateca_certificate" "default" {
  pool     = "my-pool"
  location = "us-central1"
  lifetime = "860s"
  name     = "my-sample-certificate"
  config {
    subject_config {
      subject {
        common_name         = "san1.example.com"
        country_code        = "us"
        organization        = "google"
        organizational_unit = "enterprise"
        locality            = "mountain view"
        province            = "california"
        street_address      = "1600 amphitheatre parkway"
        postal_code         = "94109"
      }
    }
    x509_config {
      ca_options {
        is_ca = false
      }
      key_usage {
        base_key_usage {
          crl_sign = true
        }
        extended_key_usage {
          server_auth = true
        }
      }
    }
    public_key {
      format = "PEM"
      key    = base64encode(data.tls_public_key.example.public_key_pem)
    }
  }
  // Certificates require an authority to exist in the pool, though they don't
  // need to be explicitly connected to it
  depends_on = [google_privateca_certificate_authority.authority]
}

resource "tls_private_key" "example" {
  algorithm = "RSA"
}

data "tls_public_key" "example" {
  private_key_pem = tls_private_key.example.private_key_pem
}

Meminta sertifikat dalam mode validasi

Meminta sertifikat dalam mode validasi akan membuat sertifikat pengujian yang tidak ditandatangani. Sertifikat pengujian ini tidak dienkode PEM dan tidak dikenai biaya. Meskipun Anda tidak dapat mendownload sertifikat, deskripsi sertifikat hipotetis memungkinkan Anda mengonfirmasi bahwa Anda berhasil menerbitkan sertifikat yang ditandatangani dengan parameter yang dipilih.

Untuk meminta sertifikat dalam mode validasi, ikuti langkah-langkah berikut:

Konsol

Buka halaman Certificate Authority Service di konsol Google Cloud.

Buka Certificate Authority Service
Klik Minta sertifikat.
Pilih Gunakan mode validasi untuk deskripsi sertifikat hipotetis, bukan sertifikat yang ditandatangani.
Ikuti langkah-langkah yang sama seperti yang Anda lakukan untuk meminta sertifikat yang ditandatangani.

Langkah selanjutnya

Pelajari profil sertifikat.
Pelajari cara mencabut sertifikat.
Pelajari cara mengurutkan dan memfilter sertifikat.
Pelajari cara mengelola sertifikat menggunakan Google Cloud CLI.