Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

בקשת אישור

בדף הזה מוסבר איך ליצור בקשת אישור בשירות Certificate Authority Service.

אפשר לבקש אישור באחת מהדרכים הבאות:

יוצרים מפתח פרטי או ציבורי משלכם ושולחים בקשה לחתימת אישור (CSR).
שימוש במפתח פרטי או ציבורי שנוצר באופן אוטומטי על ידי CA Service.
שימוש במפתח קיים של Cloud Key Management Service ‏ (Cloud KMS).

לפני שמתחילים

הכנת הסביבה ל-CA Service.
כדי לקבל את ההרשאות שנדרשות להנפקת אישורים, צריך לבקש מהאדמין להקצות לכם ב-IAM את התפקיד CA Service Certificate Requester (roles/privateca.certificateRequester) או CA Service Certificate Manager (roles/privateca.certificateManager).

מידע נוסף על התפקידים המוגדרים מראש ב-IAM עבור CA Service זמין במאמר בקרת גישה באמצעות IAM.

מידע על הקצאת תפקיד IAM לחשבון משתמש מופיע במאמר הקצאת תפקיד יחיד.

בקשת אישור באמצעות CSR

כדי לקבל אישור, יוצרים CSR, ואז משתמשים בו כדי לבקש את האישור.

יצירת ה-CSR

הוראות מפורטות ליצירת בקשת חתימה (CSR) באמצעות OpenSSL מופיעות במאמר איך ליצור בקשת חתימה (CSR) באמצעות OpenSSL. אפשר גם להשתמש בקובץ התצורה לדוגמה הבא כהפניה כשיוצרים את בקשת ה-CSR.

כדי להשתמש בקובץ התצורה לדוגמה:

יוצרים קובץ תצורה בשם csr.cnf עם ההגדרות הבאות.
```
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
```
בדוגמה הזו נוצר מפתח RSA של 2048 ביט (מוצפן באמצעות סיסמה) ו-CSR תואם שמכיל את הפרטים הבאים:
- המאפיין commonName בשם הדומיין של הנושא
- התוסף subjectAlternativeName
- התוסף keyUsage (מסומן כקריטי)
- התוסף extendedKeyUsage
משנים את הפרמטרים לפי הצורך. כדי להשתמש בפורמט של קובץ ההגדרות x509v3_config כדי להגדיר תוספים לאישורי X.509 ולבקשות CSR, אפשר לעיין בתיעוד של OpenSSL.
מריצים את הפקודה הבאה openssl כדי ליצור בקשת חתימה (CSR) ומפתח פרטי תואם:
```
openssl req -newkey rsa:2048 -out csr.pem -keyout key.pem -config csr.cnf
```
הפקודה הזו יוצרת את הקבצים הבאים:
- ‫csr.pem: בקשת ה-CSR שלכם, מוכנה לשליחה לרשות אישורים
- ‫key.pem: המפתח הפרטי שלכם, שצריך לשמור אותו בצורה מאובטחת
משתמשים בקובץ csr.pem בבקשת האישור.

שליחת בקשת אישור באמצעות ה-CSR

כדי לבקש אישור באמצעות ה-CSR, פועלים לפי השלבים הבאים:

המסוף

נכנסים לדף Certificate Authority Service במסוףGoogle Cloud .

כניסה אל Certificate Authority Service
לוחצים על בקשת אישור.
בחירת אזור. האזור צריך להיות זהה לאזור של מאגר אישורי ה-CA שבו אתם מתכוונים להשתמש.
בוחרים מאגר של רשויות אישורים.
אופציונלי: בוחרים רשות אישורים ספציפית ממאגר רשויות האישורים. שימו לב: כשבוחרים רשות אישורים ספציפית להנפקת אישורים, נוצרת תלות ברשות האישורים הזו, ולכן קשה יותר להחליף רשויות אישורים.
אופציונלי: בוחרים תבנית לאישור. אם משתמשים בתבנית אישור, צריך לוודא שהמדיניות של תבנית האישור לא סותרת את המדיניות של מאגר רשויות האישורים שנבחר.
לוחצים על Provide Certificate Signing Request (CSR) (הזנת בקשת חתימה על אישור) ואז על Next (הבא). פרטי האישור מוצגים.
אופציונלי: כדי להחליף את השם של האישור שנוצר אוטומטית, מזינים את השם המותאם אישית בשדה שם האישור. אחרי שיוצרים את האישור, אי אפשר למחוק את שם האישור או להשתמש בו שוב.
אופציונלי: כדי לבחור תקופת תוקף מותאמת אישית לאישור, מזינים את הערך בשדה Valid for.
מעתיקים את ה-CSR ומדביקים אותו בתיבה Certificate CSR (בקשת חתימה על אישור). אם רוצים להעלות קובץ שמכיל את בקשת ה-CSR, לוחצים על עיון ואז בוחרים את הקובץ.
לוחצים על יצירת אישור.

הורדת האישור החתום

כדי לראות את האישור שנוצר, לוחצים על הצגת האישור ואז על הצגה.
כדי להעתיק את האישור, לוחצים על . כדי להוריד את האישור כקובץ .crt, לוחצים על הורדת האישור.
אופציונלי: כדי להוריד את שרשרת האישורים, לוחצים על הורדת שרשרת האישורים.

gcloud

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

מחליפים את מה שכתוב בשדות הבאים:

‫CERT_ID: המזהה הייחודי של האישור
‫POOL_ID: השם של מאגר רשות האישורים
‫ISSUER_LOCATION: המיקום של האישור
‫CSR_FILENAME: הקובץ שבו מאוחסן ה-CSR בקידוד PEM
‫CERT_OUTPUT_FILE: הנתיב שבו צריך לכתוב את קובץ שרשרת האישורים בקידוד PEM. שרשרת האישורים מסודרת מישות קצה לאישור בסיס.

הדגל --validity מגדיר את משך הזמן שבו האישור תקף. זהו דגל אופציונלי שערך ברירת המחדל שלו הוא 30 ימים.

מידע נוסף על הפקודה gcloud privateca certificates create זמין במאמר 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"
  }
}

‫API בארכיטקטורת REST

יוצרים בקשת חתימה על אישור (CSR) באמצעות השיטה המועדפת, למשל openssl.

הנה דוגמה ל-CSR שמקודד ל-JSON.

לבקש אישור.

ה-method של ה-HTTP וכתובת ה-URL:
```
POST https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificates?certificate_id=CERTIFICATE_ID
```
תוכן בקשת JSON:
```
{
    "lifetime": {
    "seconds": 3600,
    "nanos": 0
    },
    "pem_csr": "PEM_CSR"
}
```
כדי לשלוח את הבקשה צריך להרחיב אחת מהאפשרויות הבאות:
‫Curl (Linux,‏ macOS או Cloud Shell)

הערה: הפקודה הבאה מבוססת על ההנחה שנכנסתם ל-CLI של gcloud באמצעות חשבון המשתמש שלכם, על ידי הרצת gcloud init או gcloud auth login, או באמצעות Cloud Shell שמחבר אתכם אוטומטית ל-CLI של gcloud. כדי לבדוק איזה חשבון פעיל, אפשר להריץ את הפקודה gcloud auth list.

שומרים את גוף הבקשה בקובץ בשם request.json ומריצים את הפקודה הבאה:
```
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)

הערה: הפקודה הבאה מבוססת על ההנחה שנכנסתם ל-CLI של gcloud באמצעות חשבון המשתמש שלכם, על ידי הרצת gcloud init או gcloud auth login. כדי לבדוק איזה חשבון פעיל, אפשר להריץ את הפקודה gcloud auth list.

שומרים את גוף הבקשה בקובץ בשם request.json ומריצים את הפקודה הבאה:
```
$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
```
אתם אמורים לקבל תגובת JSON שדומה לזו:
```
{
    "name": "projects/project-id/locations/location/certificateAuthorities/ca-id/certificates/certificate-id",
    "pemCertificate": "-----BEGIN CERTIFICATE-----...",
    "certificateDescription": {...}
}
```
שימו לב: מומלץ לא להנפיק אישורים של ישויות קצה מ-CA בסיסי. מידע על יצירת רשויות אישורים משניות זמין במאמר יצירת רשויות אישורים.

בקשת אישור באמצעות מפתח שנוצר אוטומטית

המסוף

אפשר להשתמש ב Google Cloud מסוף כדי ליצור אישורי לקוח או שרת TLS.

נכנסים לדף Certificate Authority Service במסוףGoogle Cloud .

כניסה אל Certificate Authority Service
לוחצים על בקשת אישור.
בחירת אזור. האזור צריך להיות זהה לאזור של מאגר אישורי ה-CA שבו אתם מתכוונים להשתמש.
בוחרים מאגר של רשויות אישורים.
לוחצים על הזנת פרטים באופן ידני. פרטי האישור מוצגים.
אופציונלי: מחליפים את שם האישור שנוצר אוטומטית בשם מותאם אישית שהוא ייחודי.
אופציונלי: כדי לבחור תקופת תוקף מותאמת אישית לאישור, מזינים את הערך בשדה Valid for.

הוספת שם דומיין

בקטע הוספת שם דומיין, מזינים שם דומיין בשדה שם דומיין 1.
אופציונלי: אם רוצים להוסיף יותר משם דומיין אחד, לוחצים על הוספת פריט ומזינים שם דומיין נוסף בשדה שם הדומיין 2.

שימוש מורחב במפתח

אופציונלי: בקטע שימוש מורחב במַפְתח, בוחרים באחת מהאפשרויות הבאות בהתאם לתרחיש השימוש:
- TLS של לקוח: האישורים האלה מאפשרים לאמת את הזהות של מבקש.
- TLS של שרת: האישורים האלה מאפשרים לכם לאמת את הזהות של שרת.
לוחצים על הבא.

הגדרה של גודל המפתח והאלגוריתם

אופציונלי: בקטע Configure key size and algorithm (הגדרת גודל המפתח והאלגוריתם), בוחרים את גודל מפתח החתימה והאלגוריתם מהרשימה. אם מדלגים על השלב הזה, נעשה שימוש במפתח RSASSA-PSS 2048 ביט עם תקציר SHA 256. מידע על בחירת מפתח חתימה ואלגוריתם מופיע במאמר בחירת אלגוריתם מפתח.
לוחצים על יצירת אישור.

הורדת האישור החתום

כדי לראות את האישור שנוצר, לוחצים על הצגת האישור ואז על הצגה.
אופציונלי: כדי להוריד את שרשרת האישורים עם קידוד PEM, לוחצים על הורדת שרשרת האישורים.
אופציונלי: כדי להוריד את המפתח הפרטי המשויך בקידוד PEM, לוחצים על הורדת מפתח פרטי.

חשוב: אי אפשר לאחזר את המפתח הזה אחרי שיוצאים מהדף. המפתח הזה רגיש. מומלץ להגן על המפתח במיקום מאובטח.
חשוב: אם אתם משתמשים במאגר של רשויות אישורים של DevOps, זו הפעם היחידה שבה תוכלו להוריד את האישור שנוצר. שירות ה-CA לא שומר את התוכן של האישור אחרי שעוברים את המסך הזה.

gcloud

כדי להשתמש בתכונה של יצירת מפתח אוטומטית, צריך להתקין את ספריית Python Cryptographic Authority (PyCA). הוראות להתקנת ספריית ה קריפטוגרפיה Pyca מופיעות במאמר הכללת ספריית ה קריפטוגרפיה Pyca.

כדי ליצור אישור, משתמשים בפקודה gcloud הבאה:

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

מחליפים את מה שכתוב בשדות הבאים:

‫POOL_ID: השם של מאגר רשות האישורים
‫ISSUER_LOCATION: המיקום של האישור
‫KEY_FILENAME: הנתיב שבו צריך לכתוב את קובץ המפתח הפרטי שנוצר
‫CERT_OUTPUT_FILE: הנתיב שבו צריך לכתוב את קובץ שרשרת האישורים בקידוד PEM. שרשרת האישורים מסודרת מישות הקצה ועד לאישור הבסיס.
‫DNS_NAME: שמות חלופיים של נושאים ב-DNS (SAN) שמופרדים בפסיקים (לפחות אחד)
‫CERTIFICATE_PROFILE: המזהה הייחודי של פרופיל האישור. לדוגמה, משתמשים ב-leaf_server_tls ל-TLS של שרת ישות קצה.

הפקודה gcloud כוללת את הדגלים הבאים:

‫--generate-key: יוצר מפתח פרטי חדש מסוג RSA-2048 במחשב.

אפשר גם להשתמש בכל שילוב של הדגלים הבאים:

‫--dns-san: מאפשרת להעביר שם אחד או יותר של DNS SANs שמופרדים באמצעות פסיקים.
‫--ip-san: מאפשרת להעביר ערך אחד או יותר של שמות חלופיים של IP, מופרדים בפסיקים.
‫--uri-san: מאפשרת להעביר אחד או יותר ערכי SAN של URI שמופרדים באמצעות פסיקים.
‫--subject: מאפשר להעביר שם X.501 של נושא האישור.

מידע נוסף על הפקודה gcloud privateca certificates create זמין במאמר gcloud privateca certificates create.

המשך

כדי לבצע אימות ב-CA Service, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

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

כדי לבצע אימות ב-CA Service, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.


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

כדי לבצע אימות ב-CA Service, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

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)

בקשת אישור באמצעות מפתח Cloud KMS קיים

אפשר להשתמש ב-Google Cloud CLI רק כדי לבקש אישורים באמצעות מפתח Cloud KMS.

gcloud

כדי להשתמש במפתח Cloud KMS כדי ליצור אישור TLS של שרת ישות קצה, מריצים את הפקודה הבאה:

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

מחליפים את מה שכתוב בשדות הבאים:

‫POOL_ID: השם של מאגר רשות האישורים
‫ISSUER_LOCATION: המיקום של האישור
‫PROJECT_ID: מזהה הפרויקט
‫LOCATION_ID: המיקום של אוסף המפתחות
‫KEY_RING: השם של אוסף המפתחות שבו נמצא המפתח
‫KEY: השם של המפתח
‫KEY_VERSION: גרסת המפתח
‫CERT_OUTPUT_FILE: הנתיב של קובץ שרשרת האישורים בקידוד PEM. הקבצים בשרשרת האישורים מסודרים מהישות הסופית ועד לרמה הבסיסית (root).
‫DNS_NAME: רשימה של שמות SAN ב-DNS, מופרדים באמצעות פסיקים

הנפקת אישור מ-CA ספציפי במאגר CA

בקטע הזה מוסבר איך להנפיק אישורים מ-CA ספציפי במאגר CA.

המסוף

נכנסים לדף Certificate Authority Service במסוףGoogle Cloud .

כניסה אל Certificate Authority Service
לוחצים על בקשת אישור.
בחירת אזור. האזור צריך להיות זהה לאזור של מאגר אישורי ה-CA שבו אתם מתכוונים להשתמש.
בוחרים מאגר של רשויות אישורים.
כדי לבחור CA, לוחצים על Use a specific CA from this CA pool (שימוש ב-CA ספציפי ממאגר ה-CA הזה), ואז בוחרים CA מהרשימה.
בוחרים פרמטרים אחרים כמו שמתואר בקטע בקשת אישור באמצעות מפתח שנוצר אוטומטית או בקטע בקשת אישור באמצעות CSR.

gcloud

כדי לטרגט רשות אישורים ספציפית במאגר רשויות האישורים להנפקת אישורים, מוסיפים את הדגל --ca עם ה-CA_ID של רשות האישורים שצריכה להנפיק את האישור.

gcloud privateca certificates create \
    --issuer-pool POOL_ID \
    --issuer-location ISSUER_LOCATION \
    --ca CA_ID \
    --generate-key \
    --key-output-file KEY_FILENAME \
    --cert-output-file CERT_OUTPUT_FILE \
    --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
}

שליחת בקשה לאישור במצב אימות

כשמבקשים אישור במצב אימות, נוצר אישור בדיקה לא חתום. אישור הבדיקה הזה לא מקודד ב-PEM ולא כרוך בתשלום. אי אפשר להוריד את האישור, אבל תיאור האישור ההיפותטי מאפשר לכם לוודא שאתם יכולים להנפיק אישור חתום עם הפרמטרים שבחרתם.

כדי לבקש אישור במצב אימות, צריך לפעול לפי השלבים הבאים:

המסוף

נכנסים לדף Certificate Authority Service במסוףGoogle Cloud .

כניסה אל Certificate Authority Service
לוחצים על בקשת אישור.
בוחרים באפשרות Use validation mode for a hypothetical certificate description instead of a signed certificate (שימוש במצב אימות לתיאור היפותטי של אישור במקום באישור חתום).
פועלים לפי אותם השלבים שבהם משתמשים כדי לבקש אישור חתום.

בקשת אישור

לפני שמתחילים

בקשת אישור באמצעות CSR

יצירת ה-CSR

שליחת בקשת אישור באמצעות ה-CSR

המסוף

gcloud

Terraform

‫API בארכיטקטורת REST

‫Curl (Linux,‏ macOS או Cloud Shell)

‎PowerShell (Windows)

בקשת אישור באמצעות מפתח שנוצר אוטומטית

המסוף

gcloud

המשך

Java

Python

בקשת אישור באמצעות מפתח Cloud KMS קיים

gcloud

הנפקת אישור מ-CA ספציפי במאגר CA

המסוף

gcloud

Terraform

שליחת בקשה לאישור במצב אימות

המסוף

המאמרים הבאים