‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

מפתחות Cloud KMS בניהול הלקוח

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

אם אתם רוצים לשלוט בהצפנה בעצמכם, אתם יכולים להשתמש במפתחות הצפנה בניהול הלקוח (CMEK) ב-BigQuery. במקום ש-Google תהיה הבעלים של מפתחות ההצפנה שמגינים על הנתונים שלכם ותנהל אותם, אתם שולטים במפתחות ההצפנה ומנהלים אותם ב-Cloud KMS. במאמר הזה מוסבר איך ליצור באופן ידני מפתחות Cloud KMS ל-BigQuery.

מידע נוסף על אפשרויות ההצפנה ב- Google Cloud במאמר מפתחות הצפנה בניהול הלקוח תוכלו לקרוא מידע ספציפי על CMEK, כולל היתרונות והמגבלות שלו.

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

כל נכסי הנתונים שמאוחסנים באחסון המנוהל של BigQuery תומכים ב-CMEK. עם זאת, אם אתם שולחים שאילתות גם לנתונים שמאוחסנים במקור נתונים חיצוני כמו Cloud Storage, שכולל נתונים שמוצפנים באמצעות CMEK, הצפנת הנתונים מנוהלת על ידי Cloud Storage. לדוגמה, טבלאות BigLake תומכות בנתונים שמוצפנים באמצעות CMEK ב-Cloud Storage.

בטבלאות BigQuery ו-BigLake אי אפשר להשתמש במפתחות הצפנה באספקת הלקוח (CSEK).
מחליטים אם להריץ את BigQuery ואת Cloud KMS באותו פרויקט ב- Google Cloud או בפרויקטים שונים. למטרות הדגמה, במאמרי העזרה נעשה שימוש במוסכמה הבאה:
- ‫PROJECT_ID: מזהה הפרויקט שבו פועל BigQuery
- ‫PROJECT_NUMBER: מספר הפרויקט שבו פועל BigQuery
- ‫KMS_PROJECT_ID: מזהה הפרויקט שבו פועל Cloud KMS (גם אם זה אותו פרויקט שבו פועל BigQuery)
למידע על מזהי פרויקטים ומספרי פרויקטים, קראו את המאמר איתור השם, המספר והמזהה של הפרויקט. Google Cloud
‫BigQuery מופעל באופן אוטומטי בפרויקטים חדשים. אם אתם משתמשים בפרויקט קיים כדי להריץ את BigQuery, הפעילו את BigQuery API.
בפרויקט ב- Google Cloud שבו פועל Cloud KMS, מפעילים את Cloud Key Management Service API.

קריאת פענוח מתבצעת באמצעות Cloud KMS פעם אחת לכל שאילתה בטבלה שמוצפנת באמצעות CMEK. מידע נוסף זמין במאמר התמחור של Cloud KMS.

מפרט ההצפנה

המפתחות של Cloud KMS שמשמשים להגנה על הנתונים שלכם ב-BigQuery הם מפתחות AES-256. המפתחות האלה משמשים כמפתחות להצפנת מפתחות הצפנה ב-BigQuery, בכך שהם מצפינים את המפתחות להצפנת נתונים שמצפינים את הנתונים שלכם.

יצירת מפתחות באופן ידני או אוטומטי

אתם יכולים ליצור את מפתחות ה-CMEK באופן ידני או להשתמש ב-Cloud KMS Autokey. ‫Autokey מפשט את היצירה והניהול של מפתחות CMEK באמצעות אוטומציה של הקצאה והקצאה. כשמשתמשים ב-Autokey, לא צריך להקצות מראש אוספי מפתחות, מפתחות וחשבונות שירות. במקום זאת, הם נוצרים לפי דרישה כחלק מיצירת המשאבים ב-BigQuery. מידע נוסף מופיע בסקירה הכללית על Autokey.

יצירה ידנית של אוסף מפתחות ומפתח

בפרויקט Google Cloud שבו פועל Cloud KMS, יוצרים אוסף מפתחות ומפתח, כמו שמתואר במאמר יצירת אוספי מפתחות ומפתחות. יוצרים את אוסף המפתחות במיקום שתואם למיקום של מערך הנתונים ב-BigQuery:

בכל מערך נתונים במספר אזורים צריך להשתמש באוסף מפתחות במספר אזורים ממיקום תואם. לדוגמה, מערך נתונים באזור US צריך להיות מוגן באמצעות אוסף מפתחות מהאזור us, ומערך נתונים באזור EU צריך להיות מוגן באמצעות אוסף מפתחות מהאזור europe.
בקבוצות נתונים אזוריות צריך להשתמש במפתחות אזוריים תואמים. לדוגמה, קבוצת נתונים באזור asia-northeast1 צריכה להיות מוגנת באמצעות אוסף מפתחות מהאזור asia-northeast1.
אי אפשר להשתמש באזור global כשמגדירים CMEK ל-BigQuery במסוף Google Cloud . עם זאת, אתם יכולים להשתמש באזור global כשאתם מגדירים CMEK ל-BigQuery באמצעות כלי שורת הפקודה של BigQuery או GoogleSQL.

מידע נוסף על המיקומים הנתמכים ב-BigQuery וב-Cloud KMS מופיע במאמר מיקומים ב-Cloud.

מתן הרשאת הצפנה ופענוח

כדי להגן על הנתונים ב-BigQuery באמצעות מפתח CMEK, צריך לתת לחשבון השירות של BigQuery הרשאה להצפין ולפענח באמצעות המפתח הזה. התפקיד Cloud KMS CryptoKey Encrypter/Decrypter מעניק את ההרשאה הזו.

מוודאים שחשבון השירות נוצר, ואז משתמשים במסוףGoogle Cloud כדי לזהות את מזהה חשבון השירות של BigQuery. בשלב הבא, נותנים לחשבון השירות את התפקיד המתאים להצפנה ולפענוח באמצעות Cloud KMS.

איך יוצרים חשבון שירות

כשיוצרים פרויקט, בהתחלה חשבון השירות של BigQuery לא נוצר. כדי להפעיל את היצירה של חשבון השירות, מזינים פקודה שמשתמשת בו, כמו הפקודה bq show --encryption_service_account, או קוראים ל-method‏ projects.getServiceAccount ב-API. לדוגמה:

bq show --encryption_service_account --project_id=PROJECT_ID

זיהוי המזהה של חשבון השירות

מזהה חשבון השירות של BigQuery הוא בפורמט הבא:

bq-PROJECT_NUMBER@bigquery-encryption.

השיטות הבאות מראות איך אפשר לקבוע את מזהה חשבון השירות של BigQuery בפרויקט.

המסוף

נכנסים לדף Dashboard במסוף Google Cloud .

כניסה לדף Dashboard
לוחצים על הרשימה הנפתחת Select from בחלק העליון של הדף. בחלון Select From שמופיע, בוחרים את הפרויקט.
מזהה הפרויקט ומספר הפרויקט מוצגים בכרטיס Project info בלוח הבקרה של הפרויקט:
במחרוזת הבאה, מחליפים את PROJECT_NUMBER במספר הפרויקט. המחרוזת החדשה מזהה את מזהה חשבון השירות שלכם ב-BigQuery.
```
bq-PROJECT_NUMBER@bigquery-encryption.
```

BQ

משתמשים בפקודה bq show עם הדגל --encryption_service_account כדי לזהות את מזהה חשבון השירות:

bq show --encryption_service_account

הפקודה מציגה את מזהה חשבון השירות:

                  ServiceAccountID
-------------------------------------------------------------
bq-PROJECT_NUMBER@bigquery-encryption.

הקצאת התפקיד "מצפין/מפענח"

מקצים את התפקיד Cloud KMS CryptoKey Encrypter/Decrypter לחשבון השירות של מערכת BigQuery שהעתקתם ללוח. החשבון הזה הוא בפורמט הבא:

bq-PROJECT_NUMBER@bigquery-encryption.

המסוף

פותחים את הדף מפתחות קריפטוגרפיים במסוף Google Cloud .
פותחים את הדף מפתחות קריפטוגרפיים
לוחצים על השם של אוסף המפתחות שמכיל את המפתח.
לוחצים על תיבת הסימון של מפתח ההצפנה שרוצים להוסיף לו את התפקיד. הכרטיסייה Permissions נפתחת.
לוחצים על Add member.
מזינים את כתובת האימייל של חשבון השירות, bq-PROJECT_NUMBER@bigquery-encryption..
- אם חשבון השירות כבר נמצא ברשימת החברים, יש לו תפקידים קיימים. לוחצים על הרשימה הנפתחת של התפקיד הנוכחי של חשבון השירות bq-PROJECT_NUMBER@bigquery-encryption..
לוחצים על הרשימה הנפתחת Select a role, לוחצים על Cloud KMS ואז על התפקיד Cloud KMS CryptoKey Encrypter/Decrypter.
כדי להקצות את התפקיד לחשבון השירות של bq-PROJECT_NUMBER@bigquery-encryption., לוחצים על Save.

gcloud

אפשר להשתמש ב-Google Cloud CLI כדי להקצות את התפקיד:

gcloud kms keys add-iam-policy-binding \
--project=KMS_PROJECT_ID \
--member serviceAccount:bq-PROJECT_NUMBER@bigquery-encryption. \
--role roles/cloudkms.cryptoKeyEncrypterDecrypter \
--location=KMS_KEY_LOCATION \
--keyring=KMS_KEY_RING \
KMS_KEY

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

‫KMS_PROJECT_ID: מזהה הפרויקט ב- Google Cloudשבו פועל Cloud KMS
‫PROJECT_NUMBER: מספר הפרויקט (לא מזהה הפרויקט) של הפרויקט ב- Google Cloud שבו פועל BigQuery
‫KMS_KEY_LOCATION: שם המיקום של המפתח ב-Cloud KMS
‫KMS_KEY_RING: השם של אוסף המפתחות ב-Cloud KMS
‫KMS_KEY: שם המפתח ב-Cloud KMS

המזהה של מקום המפתח

כדי להשתמש ב-CMEK, צריך את מזהה המשאב של מפתח Cloud KMS, כמו שמוצג בדוגמאות. המפתח הזה הוא תלוי אותיות רישיות, והוא מופיע בפורמט הבא:

projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY

אחזור של מזהה המשאב העיקרי

פותחים את הדף מפתחות קריפטוגרפיים במסוף Google Cloud .
פותחים את הדף מפתחות קריפטוגרפיים
לוחצים על השם של אוסף המפתחות שמכיל את המפתח.
לוחצים על More במפתח שמזהה המשאב שלו מאוחזר.
לוחצים על העתקת שם המשאב. מזהה המשאב של המפתח מועתק ללוח. מזהה המשאב נקרא גם שם המשאב.

יצירת טבלה שמוגנת באמצעות Cloud KMS

כדי ליצור טבלה שמוגנת באמצעות Cloud KMS:

המסוף

פותחים את הדף BigQuery במסוף Google Cloud .

כניסה ל-BigQuery
בחלונית השמאלית, לוחצים על Explorer:

אם החלונית הימנית לא מוצגת, לוחצים על הרחבת החלונית הימנית כדי לפתוח אותה.
בחלונית Explorer, מרחיבים את הפרויקט, לוחצים על Datasets ואז לוחצים על מערך נתונים. מערך הנתונים נפתח בכרטיסייה.
בחלונית הפרטים, לוחצים על Create table.
בדף Create table, ממלאים את הפרטים שצריך כדי ליצור טבלה ריקה עם הגדרת סכימה. לפני שלוחצים על Create Table, מגדירים את סוג ההצפנה ומציינים את מפתח Cloud KMS שבו רוצים להשתמש בטבלה:
1. לוחצים על אפשרויות מתקדמות.
2. לוחצים על מפתח בניהול הלקוח.
3. בוחרים את המפתח. אם המפתח שבו רוצים להשתמש לא מופיע ברשימה, מזינים את מזהה המשאב של המפתח.
לוחצים על Create table.

SQL

משתמשים בהצהרה CREATE TABLE עם האפשרות kms_key_name:

נכנסים לדף BigQuery במסוף Google Cloud .

כניסה ל-BigQuery

בעורך השאילתות, מזינים את ההצהרה הבאה:

CREATE TABLE DATASET_ID.TABLE_ID (
  name STRING, value INT64
) OPTIONS (
    kms_key_name
      = 'projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY');

לוחצים על הפעלה.

מידע נוסף על הרצת שאילתות זמין במאמר הרצת שאילתה אינטראקטיבית.

BQ

כדי ליצור את הטבלה, אפשר להשתמש בכלי שורת הפקודה של BigQuery עם הדגל --destination_kms_key. הדגל --destination_kms_key מציין את מזהה המשאב של המפתח שבו משתמשים בטבלה.

כדי ליצור טבלה ריקה עם סכימה:

bq mk --schema name:string,value:integer -t \
--destination_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
DATASET_ID.TABLE_ID

כדי ליצור טבלה משאילתה:

bq query --destination_table=DATASET_ID.TABLE_ID \
--destination_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
"SELECT name,count FROM DATASET_ID.TABLE_ID WHERE gender = 'M' ORDER BY count DESC LIMIT 6"

למידע נוסף על כלי שורת הפקודה של BigQuery, קראו את המאמר שימוש בכלי שורת הפקודה של BigQuery.

Terraform

משתמשים במשאב google_bigquery_table.

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

בדוגמה הבאה נוצרת טבלה בשם mytable, ונעשה שימוש במשאבים google_kms_crypto_key ו-google_kms_key_ring כדי לציין מפתח Cloud Key Management Service לטבלה.

כדי להריץ את הדוגמה הזו, צריך להפעיל את Cloud Resource Manager API ואת Cloud Key Management Service API.

resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id = google_bigquery_dataset.default.dataset_id
  table_id   = "mytable"

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

  encryption_configuration {
    kms_key_name = google_kms_crypto_key.crypto_key.id
  }

  depends_on = [google_project_iam_member.service_account_access]
}

resource "google_kms_crypto_key" "crypto_key" {
  name     = "example-key"
  key_ring = google_kms_key_ring.key_ring.id
}

resource "random_id" "default" {
  byte_length = 8
}

resource "google_kms_key_ring" "key_ring" {
  name     = "${random_id.default.hex}-example-keyring"
  location = "us"
}

# Enable the BigQuery service account to encrypt/decrypt Cloud KMS keys
data "google_project" "project" {
}

resource "google_project_iam_member" "service_account_access" {
  project = data.google_project.project.project_id
  role    = "roles/cloudkms.cryptoKeyEncrypterDecrypter"
  member  = "serviceAccount:bq-${data.google_project.project.number}@bigquery-encryption.iam.gserviceaccount.com"
}

כך מחילים את ההגדרות של Terraform בפרויקט ב- Google Cloud :

הכנת Cloud Shell

מפעילים את Cloud Shell.
מגדירים את פרויקט ברירת המחדל ב- Google Cloud שבו רוצים להחיל את ההגדרות של Terraform.

תצטרכו להריץ את הפקודה הזו רק פעם אחת לכל פרויקט, ותוכלו לעשות זאת בכל ספרייה.
```
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
```
אם תגדירו ערכים ספציפיים בקובץ התצורה של Terraform, הם יבטלו את ערכי ברירת המחדל של משתני הסביבה.

הכנת הספרייה

לכל קובץ תצורה של Terraform צריכה להיות ספרייה משלו (שנקראת גם מודול ברמה הבסיסית).

יוצרים ספרייה חדשה ב-Cloud Shell ובה יוצרים קובץ חדש. שם הקובץ חייב לכלול את הסיומת .tf, למשל main.tf. במדריך הזה, הקובץ נקרא main.tf.
```
mkdir DIRECTORY && cd DIRECTORY && touch main.tf
```
אם אתם עוקבים אחרי המדריך, תוכלו להעתיק את הקוד לדוגמה בכל קטע או שלב.

מעתיקים את הקוד לדוגמה בקובץ main.tf החדש שיצרתם.

לחלופין, אפשר גם להעתיק את הקוד מ-GitHub. כדאי לעשות את זה כשקטע הקוד של Terraform הוא חלק מפתרון מקצה לקצה.
בודקים את הפרמטרים לדוגמה ומשנים אותם בהתאם לסביבה שלכם.
שומרים את השינויים.
מפעילים את Terraform. צריך לעשות זאת רק פעם אחת לכל ספרייה.
```
terraform init
```
אופציונלי: תוכלו לכלול את האפשרות -upgrade, כדי להשתמש בגרסה העדכנית ביותר של הספק של Google:
```
terraform init -upgrade
```

החלה של השינויים

בודקים את ההגדרות ומוודאים שהמשאבים שמערכת Terraform תיצור או תעדכן תואמים לציפיות שלכם:
```
terraform plan
```
מתקנים את ההגדרות לפי הצורך.
מריצים את הפקודה הבאה ומזינים yes בהודעה שמופיעה, כדי להחיל את הגדרות Terraform:
```
terraform apply
```
ממתינים עד שב-Terraform תוצג ההודעה "Apply complete!‎".
פותחים את הפרויקט ב- Google Cloud כדי להציג את התוצאות. במסוף Google Cloud , נכנסים למשאבים בממשק המשתמש כדי לוודא שהם נוצרו או עודכנו ב-Terraform.

המשך

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי הוראות ההגדרה של Go במדריך למתחילים של BigQuery באמצעות ספריות לקוח. למידע נוסף, קראו את מאמרי העזרה של BigQuery Go API.

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

import (
	"context"
	"fmt"

	"cloud.google.com/go/bigquery"
)

// createTableWithCMEK demonstrates creating a table protected with a customer managed encryption key.
func createTableWithCMEK(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydatasetid"
	// tableID := "mytableid"
	ctx := context.Background()

	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	tableRef := client.Dataset(datasetID).Table(tableID)
	meta := &bigquery.TableMetadata{
		EncryptionConfig: &bigquery.EncryptionConfig{
			// TODO: Replace this key with a key you have created in Cloud KMS.
			KMSKeyName: "projects/cloud-samples-tests/locations/us/keyRings/test/cryptoKeys/test",
		},
	}
	if err := tableRef.Create(ctx, meta); err != nil {
		return err
	}
	return nil
}

Java

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי הוראות ההגדרה של Java במדריך למתחילים של BigQuery באמצעות ספריות לקוח. למידע נוסף, קראו את מאמרי העזרה של BigQuery Java API.

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.EncryptionConfiguration;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.StandardTableDefinition;
import com.google.cloud.bigquery.TableDefinition;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;

// Sample to create a cmek table
public class CreateTableCMEK {

  public static void runCreateTableCMEK() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String kmsKeyName = "MY_KEY_NAME";
    Schema schema =
        Schema.of(
            Field.of("stringField", StandardSQLTypeName.STRING),
            Field.of("booleanField", StandardSQLTypeName.BOOL));
    // i.e. projects/{project}/locations/{location}/keyRings/{key_ring}/cryptoKeys/{cryptoKey}
    EncryptionConfiguration encryption =
        EncryptionConfiguration.newBuilder().setKmsKeyName(kmsKeyName).build();
    createTableCMEK(datasetName, tableName, schema, encryption);
  }

  public static void createTableCMEK(
      String datasetName, String tableName, Schema schema, EncryptionConfiguration configuration) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(datasetName, tableName);
      TableDefinition tableDefinition = StandardTableDefinition.of(schema);
      TableInfo tableInfo =
          TableInfo.newBuilder(tableId, tableDefinition)
              .setEncryptionConfiguration(configuration)
              .build();

      bigquery.create(tableInfo);
      System.out.println("Table cmek created successfully");
    } catch (BigQueryException e) {
      System.out.println("Table cmek was not created. \n" + e.toString());
    }
  }
}

Python

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי הוראות ההגדרה של Python במדריך למתחילים של BigQuery באמצעות ספריות לקוח. למידע נוסף, קראו את מאמרי העזרה של BigQuery Python API.

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

כדי להגן על טבלה חדשה באמצעות מפתח הצפנה בניהול הלקוח, מגדירים את המאפיין Table.encryption_configuration לאובייקט EncryptionConfiguration לפני שיוצרים את הטבלה.

from google.cloud import bigquery

client = bigquery.Client()

# TODO(dev): Change table_id to the full name of the table you want to create.
table_id = "your-project.your_dataset.your_table_name"

# Set the encryption key to use for the table.
# TODO: Replace this key with a key you have created in Cloud KMS.
kms_key_name = "projects/your-project/locations/us/keyRings/test/cryptoKeys/test"

table = bigquery.Table(table_id)
table.encryption_configuration = bigquery.EncryptionConfiguration(
    kms_key_name=kms_key_name
)
table = client.create_table(table)  # API request

print(f"Created {table_id}.")
print(f"Key: {table.encryption_configuration.kms_key_name}.")

שליחת שאילתה לטבלה שמוגנת באמצעות מפתח Cloud KMS

לא נדרשים סידורים מיוחדים כדי לשלוח שאילתה לטבלה שמוגנת על ידי Cloud KMS. ב-BigQuery נשמר השם של המפתח שמשמש להצפנת תוכן הטבלה, והמפתח הזה משמש כשנשלחת שאילתה לטבלה שמוגנת באמצעות Cloud KMS.

כל הכלים הקיימים, מסוף BigQuery וכלי שורת הפקודה של BigQuery פועלים באותו אופן כמו בטבלאות שמוצפנות כברירת מחדל, כל עוד ל-BigQuery יש גישה למפתח Cloud KMS שמשמש להצפנת תוכן הטבלה.

הגנה על תוצאות של שאילתות באמצעות מפתח Cloud KMS

כברירת מחדל, תוצאות השאילתה מאוחסנות בטבלה זמנית שמוצפנת באמצעותGoogle-owned and Google-managed encryption key. אם לפרויקט כבר יש מפתח ברירת מחדל, המפתח מוחל על טבלת התוצאות הזמנית (ברירת המחדל) של השאילתה. כדי להשתמש במפתח Cloud KMS להצפנת תוצאות השאילתה, בוחרים באחת מהאפשרויות הבאות:

המסוף

פותחים את הדף BigQuery במסוף Google Cloud .

כניסה ל-BigQuery
לוחצים על Compose new query.
מזינים שאילתת GoogleSQL תקינה באזור הטקסט של השאילתה.
לוחצים על Edit > Query settings ואז על Advanced options.
בוחרים באפשרות הצפנה בניהול הלקוח.
בוחרים את המפתח. אם המפתח שבו רוצים להשתמש לא מופיע ברשימה, מזינים את מזהה המשאב של המפתח.
לוחצים על Save.
לוחצים על Run.

BQ

מציינים את הדגל --destination_kms_key כדי להגן על טבלת היעד או על תוצאות השאילתה (אם משתמשים בטבלה זמנית) באמצעות מפתח Cloud KMS. הדגל --destination_kms_key מציין את מזהה המשאב של המפתח שבו משתמשים ביעד או בטבלה שנוצרה.

אפשר להשתמש בדגל --destination_table כדי לציין את היעד של תוצאות השאילתה. אם לא משתמשים ב---destination_table, תוצאות השאילתה נכתבות בטבלה זמנית.

כדי לשלוח שאילתה לטבלה:

bq query \
--destination_table=DATASET_ID.TABLE_ID \
--destination_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
"SELECT name,count FROM DATASET_ID.TABLE_ID WHERE gender = 'M' ORDER BY count DESC LIMIT 6"

למידע נוסף על כלי שורת הפקודה של BigQuery, קראו את המאמר שימוש בכלי שורת הפקודה של BigQuery.

המשך

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

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"google.golang.org/api/iterator"
)

// queryWithDestinationCMEK demonstrates saving query results to a destination table and protecting those results
// by specifying a customer managed encryption key.
func queryWithDestinationCMEK(w io.Writer, projectID, dstDatasetID, dstTableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	q := client.Query("SELECT 17 as my_col")
	q.Location = "US" // Location must match the dataset(s) referenced in query.
	q.QueryConfig.Dst = client.Dataset(dstDatasetID).Table(dstTableID)
	q.DestinationEncryptionConfig = &bigquery.EncryptionConfig{
		// TODO: Replace this key with a key you have created in Cloud KMS.
		KMSKeyName: "projects/cloud-samples-tests/locations/us-central1/keyRings/test/cryptoKeys/test",
	}
	// Run the query and print results when the query job is completed.
	job, err := q.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	it, err := job.Read(ctx)
	for {
		var row []bigquery.Value
		err := it.Next(&row)
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintln(w, row)
	}
	return nil
}

Java

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.EncryptionConfiguration;
import com.google.cloud.bigquery.QueryJobConfiguration;
import com.google.cloud.bigquery.TableResult;

// Sample to query on destination table with encryption key
public class QueryDestinationTableCMEK {

  public static void runQueryDestinationTableCMEK() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String kmsKeyName = "MY_KMS_KEY_NAME";
    String query =
        String.format("SELECT stringField, booleanField FROM %s.%s", datasetName, tableName);
    EncryptionConfiguration encryption =
        EncryptionConfiguration.newBuilder().setKmsKeyName(kmsKeyName).build();
    queryDestinationTableCMEK(query, encryption);
  }

  public static void queryDestinationTableCMEK(String query, EncryptionConfiguration encryption) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      QueryJobConfiguration config =
          QueryJobConfiguration.newBuilder(query)
              // Set the encryption key to use for the destination.
              .setDestinationEncryptionConfiguration(encryption)
              .build();

      TableResult results = bigquery.query(config);

      results
          .iterateAll()
          .forEach(row -> row.forEach(val -> System.out.printf("%s,", val.toString())));
      System.out.println("Query performed successfully with encryption key.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Query not performed \n" + e.toString());
    }
  }
}

Python

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

כדי להגן על טבלת יעד של שאילתה באמצעות מפתח הצפנה בניהול הלקוח, מגדירים את המאפיין QueryJobConfig.destination_encryption_configuration ל-EncryptionConfiguration ומריצים את השאילתה.

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the destination table.
# table_id = "your-project.your_dataset.your_table_name"

# Set the encryption key to use for the destination.
# TODO(developer): Replace this key with a key you have created in KMS.
# kms_key_name = "projects/{}/locations/{}/keyRings/{}/cryptoKeys/{}".format(
#     your-project, location, your-ring, your-key
# )

job_config = bigquery.QueryJobConfig(
    destination=table_id,
    destination_encryption_configuration=bigquery.EncryptionConfiguration(
        kms_key_name=kms_key_name
    ),
)

# Start the query, passing in the extra configuration.
query_job = client.query(
    "SELECT 17 AS my_col;", job_config=job_config
)  # Make an API request.
query_job.result()  # Wait for the job to complete.

table = client.get_table(table_id)  # Make an API request.
if table.encryption_configuration.kms_key_name == kms_key_name:
    print("The destination table is written using the encryption configuration")

טעינת טבלה שמוגנת באמצעות Cloud KMS

כדי לטעון קובץ נתונים לטבלה שמוגנת באמצעות Cloud KMS:

המסוף

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

פותחים את הדף BigQuery במסוף Google Cloud .

כניסה ל-BigQuery
בחלונית השמאלית, לוחצים על Explorer:
בחלונית Explorer, מרחיבים את הפרויקט, לוחצים על Datasets ואז לוחצים על מערך נתונים. מערך הנתונים נפתח בכרטיסייה.
בחלונית הפרטים, לוחצים על Create table.
מזינים את האפשרויות שבהן רוצים להשתמש כדי לטעון את הטבלה, אבל לפני שלוחצים על Create table, לוחצים על Advanced options.
בקטע Encryption, בוחרים באפשרות Customer-managed key.
לוחצים על הרשימה הנפתחת Select a customer-managed key ובוחרים את המפתח שבו רוצים להשתמש. אם לא מופיעים מפתחות, מזינים מזהה משאב של מפתח.
לוחצים על Create table.

BQ

כדי להגן על טבלת היעד של משימת טעינה באמצעות מפתח הצפנה בניהול הלקוח, מגדירים את הדגל --destination_kms_key.

bq --location=LOCATION load \
--autodetect \
--source_format=FORMAT \
--destination_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
DATASET.TABLE \
path_to_source

לדוגמה:

bq load \
--autodetect \
--source_format=NEWLINE_DELIMITED_JSON \
--destination_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
test2.table4 \
gs://cloud-samples-data/bigquery/us-states/us-states.json

המשך

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

import (
	"context"
	"fmt"

	"cloud.google.com/go/bigquery"
)

// importJSONWithCMEK demonstrates loading newline-delimited JSON from Cloud Storage,
// and protecting the data with a customer-managed encryption key.
func importJSONWithCMEK(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	gcsRef := bigquery.NewGCSReference("gs://cloud-samples-data/bigquery/us-states/us-states.json")
	gcsRef.SourceFormat = bigquery.JSON
	gcsRef.AutoDetect = true
	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(gcsRef)
	loader.WriteDisposition = bigquery.WriteEmpty
	loader.DestinationEncryptionConfig = &bigquery.EncryptionConfig{
		// TODO: Replace this key with a key you have created in KMS.
		KMSKeyName: "projects/cloud-samples-tests/locations/us-central1/keyRings/test/cryptoKeys/test",
	}

	job, err := loader.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}

	if status.Err() != nil {
		return fmt.Errorf("job completed with error: %v", status.Err())
	}

	return nil
}

Java

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.EncryptionConfiguration;
import com.google.cloud.bigquery.FormatOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.TableId;

// Sample to load JSON data with configuration key from Cloud Storage into a new BigQuery table
public class LoadJsonFromGCSCMEK {

  public static void runLoadJsonFromGCSCMEK() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String kmsKeyName = "MY_KMS_KEY_NAME";
    String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.json";
    // i.e. projects/{project}/locations/{location}/keyRings/{key_ring}/cryptoKeys/{cryptoKey}
    EncryptionConfiguration encryption =
        EncryptionConfiguration.newBuilder().setKmsKeyName(kmsKeyName).build();
    loadJsonFromGCSCMEK(datasetName, tableName, sourceUri, encryption);
  }

  public static void loadJsonFromGCSCMEK(
      String datasetName, String tableName, String sourceUri, EncryptionConfiguration encryption) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(datasetName, tableName);
      LoadJobConfiguration loadConfig =
          LoadJobConfiguration.newBuilder(tableId, sourceUri)
              // Set the encryption key to use for the destination.
              .setDestinationEncryptionConfiguration(encryption)
              .setFormatOptions(FormatOptions.json())
              .setAutodetect(true)
              .build();

      // Load data from a GCS JSON file into the table
      Job job = bigquery.create(JobInfo.of(loadConfig));
      // Blocks until this load table job completes its execution, either failing or succeeding.
      job = job.waitFor();
      if (job.isDone()) {
        System.out.println("Table loaded succesfully from GCS with configuration key");
      } else {
        System.out.println(
            "BigQuery was unable to load into the table due to an error:"
                + job.getStatus().getError());
      }
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Column not added during load append \n" + e.toString());
    }
  }
}

Python

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

כדי להגן על טבלת היעד של משימת הטעינה באמצעות מפתח הצפנה בניהול הלקוח, מגדירים את המאפיין LoadJobConfig.destination_encryption_configuration ל-EncryptionConfiguration וטוענים את הטבלה.

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the table to create.
# table_id = "your-project.your_dataset.your_table_name

# Set the encryption key to use for the destination.
# TODO: Replace this key with a key you have created in KMS.
# kms_key_name = "projects/{}/locations/{}/keyRings/{}/cryptoKeys/{}".format(
#     "cloud-samples-tests", "us", "test", "test"
# )

job_config = bigquery.LoadJobConfig(
    autodetect=True,
    source_format=bigquery.SourceFormat.NEWLINE_DELIMITED_JSON,
    destination_encryption_configuration=bigquery.EncryptionConfiguration(
        kms_key_name=kms_key_name
    ),
)

uri = "gs://cloud-samples-data/bigquery/us-states/us-states.json"

load_job = client.load_table_from_uri(
    uri,
    table_id,
    location="US",  # Must match the destination dataset location.
    job_config=job_config,
)  # Make an API request.

assert load_job.job_type == "load"

load_job.result()  # Waits for the job to complete.

assert load_job.state == "DONE"
table = client.get_table(table_id)

if table.encryption_configuration.kms_key_name == kms_key_name:
    print("A table loaded with encryption configuration key")

העברת נתונים בסטרימינג לטבלה שמוגנת באמצעות Cloud KMS

אתם יכולים להעביר נתונים בסטרימינג לטבלה ב-BigQuery שמוגנת באמצעות CMEK, בלי לציין פרמטרים נוספים. שימו לב שהנתונים האלה מוצפנים באמצעות מפתח Cloud KMS במאגר וגם במיקום הסופי. לפני שמשתמשים בסטרימינג עם טבלת CMEK, צריך לבדוק את הדרישות בנושא זמינות ונגישות של מפתחות.

מידע נוסף על סטרימינג של נתונים באמצעות BigQuery Storage Write API ‏ (gRPC)

שינוי טבלה מהצפנה שמוגדרת כברירת מחדל להגנה באמצעות Cloud KMS

BQ

אתם יכולים להשתמש בפקודה bq cp עם הדגל --destination_kms_key כדי להעתיק טבלה שמוגנת באמצעות הצפנת ברירת המחדל לטבלה חדשה, או לטבלה המקורית, שמוגנת באמצעות Cloud KMS. הדגל --destination_kms_key מציין את מזהה המשאב של המפתח שבו משתמשים בטבלת היעד.

כדי להעתיק טבלה עם הצפנה כברירת מחדל לטבלה חדשה עם הגנה של Cloud KMS:

bq cp \
--destination_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
SOURCE_DATASET_ID.SOURCE_TABLE_ID DESTINATION_DATASET_ID.DESTINATION_TABLE_ID

אם רוצים להעתיק טבלה עם הצפנת ברירת מחדל לאותה טבלה עם הגנה של Cloud KMS:

bq cp -f \
--destination_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
DATASET_ID.TABLE_ID DATASET_ID.TABLE_ID

אם רוצים לשנות טבלה מהגנה של Cloud KMS להצפנת ברירת מחדל, מעתיקים את הקובץ לעצמו על ידי הפעלת bq cp בלי להשתמש בדגל --destination_kms_key.

למידע נוסף על כלי שורת הפקודה של BigQuery, קראו את המאמר שימוש בכלי שורת הפקודה של BigQuery.

המשך

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

import (
	"context"
	"fmt"

	"cloud.google.com/go/bigquery"
)

// copyTableWithCMEK demonstrates creating a copy of a table and ensuring the copied data is
// protected with a customer managed encryption key.
func copyTableWithCMEK(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	srcTable := client.DatasetInProject("bigquery-public-data", "samples").Table("shakespeare")
	copier := client.Dataset(datasetID).Table(tableID).CopierFrom(srcTable)
	copier.DestinationEncryptionConfig = &bigquery.EncryptionConfig{
		// TODO: Replace this key with a key you have created in Cloud KMS.
		KMSKeyName: "projects/cloud-samples-tests/locations/us-central1/keyRings/test/cryptoKeys/test",
	}
	job, err := copier.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	return nil
}

Java

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.CopyJobConfiguration;
import com.google.cloud.bigquery.EncryptionConfiguration;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.TableId;

// Sample to copy a cmek table
public class CopyTableCMEK {

  public static void runCopyTableCMEK() {
    // TODO(developer): Replace these variables before running the sample.
    String destinationDatasetName = "MY_DESTINATION_DATASET_NAME";
    String destinationTableId = "MY_DESTINATION_TABLE_NAME";
    String sourceDatasetName = "MY_SOURCE_DATASET_NAME";
    String sourceTableId = "MY_SOURCE_TABLE_NAME";
    String kmsKeyName = "MY_KMS_KEY_NAME";
    EncryptionConfiguration encryption =
        EncryptionConfiguration.newBuilder().setKmsKeyName(kmsKeyName).build();
    copyTableCMEK(
        sourceDatasetName, sourceTableId, destinationDatasetName, destinationTableId, encryption);
  }

  public static void copyTableCMEK(
      String sourceDatasetName,
      String sourceTableId,
      String destinationDatasetName,
      String destinationTableId,
      EncryptionConfiguration encryption) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId sourceTable = TableId.of(sourceDatasetName, sourceTableId);
      TableId destinationTable = TableId.of(destinationDatasetName, destinationTableId);

      // For more information on CopyJobConfiguration see:
      // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/bigquery/JobConfiguration.html
      CopyJobConfiguration configuration =
          CopyJobConfiguration.newBuilder(destinationTable, sourceTable)
              .setDestinationEncryptionConfiguration(encryption)
              .build();

      // For more information on Job see:
      // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html
      Job job = bigquery.create(JobInfo.of(configuration));

      // Blocks until this job completes its execution, either failing or succeeding.
      Job completedJob = job.waitFor();
      if (completedJob == null) {
        System.out.println("Job not executed since it no longer exists.");
        return;
      } else if (completedJob.getStatus().getError() != null) {
        System.out.println(
            "BigQuery was unable to copy table due to an error: \n" + job.getStatus().getError());
        return;
      }
      System.out.println("Table cmek copied successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Table cmek copying job was interrupted. \n" + e.toString());
    }
  }
}

Python

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

כדי להגן על היעד של עותק הטבלה באמצעות מפתח הצפנה בניהול הלקוח, מגדירים את המאפיין QueryJobConfig.destination_encryption_configuration ל-EncryptionConfiguration ומעתיקים את הטבלה.

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set dest_table_id to the ID of the destination table.
# dest_table_id = "your-project.your_dataset.your_table_name"

# TODO(developer): Set orig_table_id to the ID of the original table.
# orig_table_id = "your-project.your_dataset.your_table_name"

# Set the encryption key to use for the destination.
# TODO(developer): Replace this key with a key you have created in KMS.
# kms_key_name = "projects/{}/locations/{}/keyRings/{}/cryptoKeys/{}".format(
#     your-project, location, your-ring, your-key
# )

job_config = bigquery.CopyJobConfig(
    destination_encryption_configuration=bigquery.EncryptionConfiguration(
        kms_key_name=kms_key_name
    )
)
job = client.copy_table(orig_table_id, dest_table_id, job_config=job_config)
job.result()  # Wait for the job to complete.

dest_table = client.get_table(dest_table_id)  # Make an API request.
if dest_table.encryption_configuration.kms_key_name == kms_key_name:
    print("A copy of the table created")

איך בודקים אם טבלה מוגנת באמצעות Cloud KMS

במסוף Google Cloud , לוחצים על החץ הכחול שמימין למערך הנתונים כדי להרחיב אותו, או לוחצים לחיצה כפולה על שם מערך הנתונים. כך מוצגות הטבלאות והתצוגות במערך הנתונים.
לוחצים על שם הטבלה.
לוחצים על פרטים. בדף Table Details מוצגים התיאור והמידע של הטבלה.
אם הטבלה מוגנת באמצעות Cloud KMS, בשדה Customer-Managed Encryption Key מוצג מזהה המשאב של המפתח.

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

שינוי מפתח Cloud KMS של טבלה ב-BigQuery

כדי לשנות את מפתח Cloud KMS של טבלה קיימת שמוגנת באמצעות CMEK, אפשר להריץ שאילתת ALTER TABLE, להשתמש ב-API או להשתמש בכלי שורת הפקודה של bq. יש שתי דרכים לשנות את המפתח של Cloud KMS באמצעות ה-API וכלי שורת הפקודה של BigQuery: ‏update או cp.

אם אתם משתמשים ב-update, אתם יכולים לשנות את מפתח Cloud KMS שמשמש לטבלה שמוגנת באמצעות CMEK.

אם אתם משתמשים ב-cp, אתם יכולים לשנות את מפתח Cloud KMS שמשמש לטבלה שמוגנת באמצעות CMEK, לשנות טבלה מהצפנת ברירת מחדל להגנה באמצעות CMEK, או לשנות טבלה מהגנה באמצעות CMEK להצפנת ברירת מחדל.

אחד היתרונות של update הוא שהיא מהירה יותר מ-cp ומאפשרת להשתמש במעצבי טבלאות.

SQL

משתמשים בהצהרת ALTER TABLE SET OPTIONS כדי לעדכן את השדה kms_key_name בטבלה:

נכנסים לדף BigQuery במסוף Google Cloud .

כניסה ל-BigQuery

בעורך השאילתות, מזינים את ההצהרה הבאה:

ALTER TABLE DATASET_ID.mytable
SET OPTIONS (
  kms_key_name
    = 'projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY');

לוחצים על הפעלה.

מידע נוסף על הרצת שאילתות זמין במאמר הרצת שאילתה אינטראקטיבית.

BQ

אתם יכולים להשתמש בפקודה bq cp עם הדגל --destination_kms_key כדי לשנות את המפתח של טבלה שמוגנת באמצעות Cloud KMS. הדגל --destination_kms_key מציין את מזהה המשאב של המפתח שבו משתמשים בטבלה.

bq update \
--destination_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
-t DATASET_ID.TABLE_ID

המשך

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

import (
	"context"
	"fmt"

	"cloud.google.com/go/bigquery"
)

// updateTableChangeCMEK demonstrates how to change the customer managed encryption key that protects a table.
func updateTableChangeCMEK(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydatasetid"
	// tableID := "mytableid"
	ctx := context.Background()

	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	tableRef := client.Dataset(datasetID).Table(tableID)
	meta, err := tableRef.Metadata(ctx)
	if err != nil {
		return err
	}
	update := bigquery.TableMetadataToUpdate{
		EncryptionConfig: &bigquery.EncryptionConfig{
			// TODO: Replace this key with a key you have created in Cloud KMS.
			KMSKeyName: "projects/cloud-samples-tests/locations/us-central1/keyRings/test/cryptoKeys/otherkey",
		},
	}
	if _, err := tableRef.Update(ctx, update, meta.ETag); err != nil {
		return err
	}
	return nil
}

Java

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.EncryptionConfiguration;
import com.google.cloud.bigquery.Table;
import com.google.cloud.bigquery.TableId;

// Sample to update a cmek table
public class UpdateTableCMEK {

  public static void runUpdateTableCMEK() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String kmsKeyName = "MY_KEY_NAME";
    // Set a new encryption key to use for the destination.
    // i.e. projects/{project}/locations/{location}/keyRings/{key_ring}/cryptoKeys/{cryptoKey}
    EncryptionConfiguration encryption =
        EncryptionConfiguration.newBuilder().setKmsKeyName(kmsKeyName).build();
    updateTableCMEK(datasetName, tableName, encryption);
  }

  public static void updateTableCMEK(
      String datasetName, String tableName, EncryptionConfiguration encryption) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      Table table = bigquery.getTable(TableId.of(datasetName, tableName));
      bigquery.update(table.toBuilder().setEncryptionConfiguration(encryption).build());
      System.out.println("Table cmek updated successfully");
    } catch (BigQueryException e) {
      System.out.println("Table cmek was not updated. \n" + e.toString());
    }
  }
}

Python

כדי לשנות את מפתח ההצפנה בניהול הלקוח של טבלה, משנים את המאפיין Table.encryption_configuration לאובייקט EncryptionConfiguration חדש ומעדכנים את הטבלה.

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

# from google.cloud import bigquery
# client = bigquery.Client()

assert table.encryption_configuration.kms_key_name == original_kms_key_name

# Set a new encryption key to use for the destination.
# TODO: Replace this key with a key you have created in KMS.
updated_kms_key_name = (
    "projects/cloud-samples-tests/locations/us/keyRings/test/cryptoKeys/otherkey"
)
table.encryption_configuration = bigquery.EncryptionConfiguration(
    kms_key_name=updated_kms_key_name
)

table = client.update_table(table, ["encryption_configuration"])  # API request

assert table.encryption_configuration.kms_key_name == updated_kms_key_name
assert original_kms_key_name != updated_kms_key_name

הגדרת מפתח ברירת מחדל למערך נתונים

אתם יכולים להגדיר מפתח Cloud KMS כברירת מחדל לכל קבוצת הנתונים, שיוחל על כל הטבלאות החדשות שנוצרות בקבוצת הנתונים, אלא אם צוין מפתח Cloud KMS אחר כשאתם יוצרים את הטבלה. מפתח ברירת המחדל לא חל על טבלאות קיימות. שינוי מפתח ברירת המחדל לא משנה את הטבלאות הקיימות, אלא חל רק על טבלאות חדשות שנוצרו אחרי השינוי.

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

SQL

נכנסים לדף BigQuery במסוף Google Cloud .

כניסה לדף BigQuery
בעורך השאילתות, מזינים את אחת מההצהרות הבאות:
- כדי להגדיר את מפתח ברירת המחדל כשיוצרים קבוצת נתונים, משתמשים בהצהרה CREATE SCHEMA עם האפשרות default_kms_key_name:
```
CREATE SCHEMA PROJECT_ID.DATASET_ID
OPTIONS (
  default_kms_key_name = 'projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY',
  location = 'LOCATION');
```
- כדי לשנות את מפתח ברירת המחדל של קבוצת נתונים, משתמשים בהצהרה ALTER SCHEMA SET OPTIONS:
```
ALTER SCHEMA PROJECT_ID.DATASET_ID
SET OPTIONS (
  default_kms_key_name = 'projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY');
```
- כדי להסיר את מפתח ברירת המחדל מקבוצת נתונים, מגדירים את default_kms_key_name ל-NULL:
```
ALTER SCHEMA PROJECT_ID.DATASET_ID
SET OPTIONS (
  default_kms_key_name = NULL);
```
לוחצים על Run.

BQ

כדי להגדיר את מפתח ברירת המחדל כשיוצרים קבוצת נתונים, משתמשים בפקודה bq mk עם הדגלים --dataset ו---default_kms_key:

bq mk --dataset 

--default_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY 

PROJECT_ID:DATASET_ID

כדי להגדיר או לשנות את מפתח ברירת המחדל של מערך נתונים קיים, משתמשים בפקודה bq update עם הדגלים --dataset ו---default_kms_key:

bq update --dataset 

--default_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY 

PROJECT_ID:DATASET_ID

כדי להסיר את מפתח ברירת המחדל ממערך נתונים, משתמשים בפקודה bq update עם הדגל --dataset ומגדירים את --default_kms_key ל-"":

bq update --dataset --default_kms_key="" PROJECT_ID:DATASET_ID

API

כדי להגדיר או לשנות את מפתח ברירת המחדל, מציינים את מפתח ברירת המחדל בשדה EncryptionConfiguration.kmsKeyName כשמפעילים את השיטות datasets.insert או datasets.patch.

כדי להסיר את מפתח ברירת המחדל, מגדירים את EncryptionConfiguration.kmsKeyName כ-null כשמפעילים את ה-method‏ datasets.patch.

הגדרת מפתח ברירת מחדל לפרויקט

אתם יכולים להגדיר מפתחות Cloud KMS כברירת מחדל לפרויקט, שחלים על כל תוצאות השאילתות ועל הטבלאות החדשות שנוצרו בפרויקט במיקום הזה, אלא אם תציינו מפתח Cloud KMS אחר. מפתח ברירת המחדל חל גם על טבלאות חדשות של תוצאות שנשמרו במטמון, שמאוחסנות במערכי נתונים אנונימיים.

מפתח ברירת המחדל לא חל על טבלאות קיימות. שינוי מפתח ברירת המחדל לא משנה את הטבלאות הקיימות, אלא חל רק על טבלאות חדשות שנוצרות אחרי השינוי.

SQL

משתמשים בהצהרה ALTER PROJECT SET OPTIONS כדי לעדכן את השדה default_kms_key_name של פרויקט. שם המשאב של המפתח מופיע בדף Cloud KMS.

נכנסים לדף BigQuery במסוף Google Cloud .

כניסה ל-BigQuery

בעורך השאילתות, מזינים את ההצהרה הבאה:

ALTER PROJECT PROJECT_ID
SET OPTIONS (
  `region-LOCATION.default_kms_key_name`
    = 'projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY');

לוחצים על הפעלה.

מידע נוסף על הרצת שאילתות זמין במאמר הרצת שאילתה אינטראקטיבית.

BQ

אפשר להשתמש בפקודה bq כדי להריץ הצהרת ALTER PROJECT SET OPTIONS ולעדכן את השדה default_kms_key_name של פרויקט:

bq query --nouse_legacy_sql \
  'ALTER PROJECT PROJECT_ID
  SET OPTIONS (
  `region-LOCATION.default_kms_key_name`
    ="projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY");'

שימוש ב-CMEK כדי להגן על מודלים של BigQuery ML

‫BigQuery ML תומך ב-CMEK. בנוסף להצפנה שמוגדרת כברירת מחדל ב-BigQuery, אתם יכולים להשתמש במפתחות משלכם ב-Cloud Key Management Service כדי להצפין מודלים של למידת מכונה, כולל מודלים מיובאים של TensorFlow.

יצירת מודל מוצפן באמצעות מפתח Cloud KMS

כדי ליצור מודל מוצפן, משתמשים בהצהרת CREATE MODEL ומציינים את KMS_KEY_NAME באפשרויות האימון:

    CREATE MODEL my_dataset.my_model
    OPTIONS(
      model_type='linear_reg',
      input_label_cols=['your_label'],
      kms_key_name='projects/my_project/locations/my_location/keyRings/my_ring/cryptoKeys/my_key')
    AS SELECT * FROM my_dataset.my_data

אותו תחביר חל גם על מודלים מיובאים של TensorFlow:

    CREATE MODEL my_dataset.my_model
    OPTIONS(
      model_type='tensorflow',
      path='gs://bucket/path/to/saved_model/*',
      kms_key_name='projects/my_project/locations/my_location/keyRings/my_ring/cryptoKeys/my_key')
    AS SELECT * FROM my_dataset.my_data

מגבלות

כשמצפינים מודלים של למידת מכונה, חלות ההגבלות הבאות על מפתחות הצפנה בניהול הלקוח:

מפתחות CMEK באזור Global לא נתמכים בסוגי המודלים הבאים:
מפתחות CMEK באזור Global ומפתחות CMEK במספר אזורים, למשל EU או US, לא נתמכים כשיוצרים את סוגי המודלים הבאים:
- מודלים של AutoML Tables
אין תמיכה במפתחות CMEK במודלים מרוחקים:

שינוי מודל מהצפנה כברירת מחדל להגנה באמצעות Cloud KMS

אתם יכולים להשתמש בפקודה bq cp עם הדגל --destination_kms_key כדי להעתיק מודל שמוגן באמצעות הצפנת ברירת המחדל למודל חדש שמוגן באמצעות Cloud KMS. לחלופין, אתם יכולים להשתמש בפקודה bq cp עם הדגל -f כדי להחליף מודל שמוגן באמצעות הצפנת ברירת המחדל, ולעדכן אותו כך שישתמש בהגנה של Cloud KMS. הדגל --destination_kms_key מציין את מזהה המשאב של המפתח שבו רוצים להשתמש במודל היעד.

כדי להעתיק מודל עם הצפנה כברירת מחדל למודל חדש עם הגנה של Cloud KMS:

bq cp \
--destination_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
SOURCE_DATASET_ID.SOURCE_MODEL_ID DESTINATION_DATASET_ID.DESTINATION_MODEL_ID

כדי להחליף מודל עם הצפנה שמוגדרת כברירת מחדל באותו מודל עם הגנה של Cloud KMS:

bq cp -f \
--destination_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
DATASET_ID.MODEL_ID DATASET_ID.MODEL_ID

כדי לשנות את ההגנה על המודל מ-Cloud KMS להצפנה שמוגדרת כברירת מחדל:

bq cp -f \
DATASET_ID.MODEL_ID DATASET_ID.MODEL_ID

למידע נוסף על כלי שורת הפקודה של BigQuery, קראו את המאמר שימוש בכלי שורת הפקודה של BigQuery.

איך בודקים אם מודל מוגן באמצעות Cloud KMS

כדי לבדוק אם המודל מוגן באמצעות מפתח Cloud KMS, משתמשים בפקודה bq show. מפתח ההצפנה נמצא בשדה kmsKeyName.

bq show -m my_dataset.my_model

אפשר גם להשתמש במסוף Google Cloud כדי למצוא את המפתח של Cloud KMS למודל מוצפן. פרטי ה-CMEK מופיעים בשדה Customer-managed key בקטע Model Details שבחלונית Details של המודל.

שינוי מפתח Cloud KMS של מודל מוצפן

משתמשים בפקודה bq update עם הדגל --destination_kms_key כדי לשנות את המפתח של מודל שמוגן באמצעות Cloud KMS:

bq update --destination_kms_key \
projects/my_project/locations/my_location/keyRings/my_ring/cryptoKeys/my_key \
-t my_dataset.my_model

שימוש במפתחות ברירת המחדל של הפרויקט או של מערך הנתונים

אם הגדרתם מפתח Cloud KMS כברירת מחדל ברמת הפרויקט או מערך הנתונים, BigQuery ML משתמש במפתח הזה באופן אוטומטי כשאתם יוצרים מודלים. אם אתם לא רוצים להשתמש במפתח ברירת המחדל, אתם יכולים להשתמש בהצהרה CREATE MODEL כדי לציין מפתח אחר להצפנת המודל.

שימוש בפונקציות של BigQuery ML עם מודלים מוצפנים

אתם יכולים להשתמש בכל הפונקציות של BigQuery ML עם מודל מוצפן בלי לציין מפתח הצפנה.

שימוש במפתחות CMEK להגנה על BigQuery Connection API

בחיבורים ל-Cloud SQL, אתם יכולים להגן על פרטי הכניסה של BigQuery Connection API באמצעות CMEK.

מידע נוסף על יצירת חיבור שמוגן באמצעות CMEK זמין במאמר יצירת חיבורים ל-Cloud SQL.

שימוש ב-CMEK כדי להגן על נכסי קוד ב-BigQuery Studio

כדי להשתמש ב-CMEK להגנה על נכסי הקוד ב-BigQuery Studio, צריך להגדיר מפתח CMEK של Dataform כברירת מחדל לפרויקט ב- Google Cloud שמכיל את נכסי הקוד. נכסי קוד כוללים את הדברים הבאים:

אחרי שמגדירים מפתח CMEK כברירת מחדל ב-Dataform, המערכת מחילה את המפתח על כל המשאבים החדשים שנוצרים בפרויקט ב- Google Cloud כברירת מחדל, כולל משאבים מוסתרים שנוצרו לאחסון נכסי הקוד.

מפתח ברירת המחדל של CMEK ב-Dataform לא חל על משאבים קיימים. אם כבר יש לכם נכסי קוד בפרויקט הזה, הם לא יוצפנו באמצעות מפתח ה-CMEK שמוגדר כברירת מחדל ב-Dataform. כדי להשתמש ב-CMEK עם נכס קוד שנוצר לפני שהגדרתם את מפתח ה-CMEK של Dataform כברירת המחדל של הפרויקט, אתם יכולים לשמור את הנכס כנכס קוד חדש ב-BigQuery Studio.

אי אפשר להגדיר ב-Dataform את הגדרת ברירת המחדל של CMEK לנכסי קוד ב-BigQuery באמצעות Terraform. במקום זאת, צריך להשתמש ב-Dataform API. צריך להחיל את ההגדרה הזו על כל פרויקט בנפרד, ולא ברמת הארגון. הוראות מופיעות במאמר הגדרת מפתח CMEK שמשמש כברירת מחדל ב-Dataform.

הסרת הגישה של BigQuery למפתח Cloud KMS

אתם יכולים להסיר את הגישה של BigQuery למפתח Cloud KMS בכל שלב, על ידי ביטול ההרשאה של ניהול זהויות והרשאות גישה (IAM) למפתח הזה.

אם ל-BigQuery אין גישה למפתח Cloud KMS, חוויית המשתמש עלולה להיפגע באופן משמעותי ועלול להתרחש אובדן נתונים:

אי אפשר יותר לגשת לנתונים בטבלאות שמוגנות באמצעות CMEK: הפעולות query, cp, extract ו-tabledata.list ייכשלו.
אי אפשר להוסיף נתונים חדשים לטבלאות שמוגנות באמצעות CMEK.
אחרי שהגישה תוחזר, יכול להיות שביצועי השאילתות בטבלאות האלה ירדו למשך כמה ימים.

שליטה בשימוש ב-CMEK באמצעות מדיניות הארגון

‫BigQuery משתלב עם אילוצים של מדיניות הארגון לגבי מפתחות CMEK, כדי שתוכלו לציין דרישות תאימות להצפנה של משאבי BigQuery בארגון.

השילוב הזה מאפשר לכם:

דרישה להשתמש במפתחות CMEK בכל המשאבים של BigQuery בפרויקט.
להגביל את מפתחות Cloud KMS שאפשר להשתמש בהם כדי להגן על משאבים בפרויקט.

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

מדיניות נפוצה היא לדרוש שימוש במפתחות CMEK כדי להגן על כל המשאבים בקבוצה ספציפית של פרויקטים. אתם יכולים להשתמש באילוץ constraints/gcp.restrictNonCmekServices כדי לאכוף את המדיניות הזו ב-BigQuery.

אם מגדירים את מדיניות הארגון הזו, כל הבקשות ליצירת משאבים בלי מפתח Cloud KMS שצוין ייכשלו.

אחרי שמגדירים את המדיניות הזו, היא חלה רק על משאבים חדשים בפרויקט. משאבים קיימים שלא מוגדרים להם מפתחות Cloud KMS ממשיכים להתקיים ואפשר לגשת אליהם בלי בעיה.

המסוף

פותחים את הדף Organization policies.

כניסה לדף Organization policies
בשדה Filter, מזינים את הערך constraints/gcp.restrictNonCmekServices ולוחצים על Restrict which services may create resources without CMEK.
לוחצים על עריכה.
בוחרים באפשרות Customize, בוחרים באפשרות Replace ולוחצים על Add Rule.
בוחרים באפשרות בהתאמה אישית ולוחצים על דחייה.
בשדה ערך מותאם אישית, מזינים is:bigquery.googleapis.com.
לוחצים על סיום ואז על שמירה.

gcloud

  gcloud resource-manager org-policies --project=PROJECT_ID \
    deny gcp.restrictNonCmekServices is:bigquery.googleapis.com

כדי לוודא שהמדיניות הוחלה, אתם יכולים לנסות ליצור טבלה בפרויקט. התהליך ייכשל אם לא תציינו מפתח Cloud KMS.

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

הגבלת מפתחות Cloud KMS לפרויקט BigQuery

אתם יכולים להשתמש באילוץ constraints/gcp.restrictCmekCryptoKeyProjects כדי להגביל את מפתחות Cloud KMS שבהם אפשר להשתמש כדי להגן על משאב בפרויקט BigQuery.

לדוגמה, אפשר לציין כלל כמו "בכל המשאבים של BigQuery ב-projects/my-company-data-project, מפתחות Cloud KMS שמשמשים בפרויקט הזה חייבים להגיע מ-projects/my-company-central-keys או מ-projects/team-specific-keys".

המסוף

פותחים את הדף Organization policies.

כניסה לדף Organization policies
בשדה Filter, מזינים את הערך constraints/gcp.restrictCmekCryptoKeyProjects ולוחצים על Restrict which projects may supply KMS CryptoKeys for CMEK.
לוחצים על עריכה.
בוחרים באפשרות Customize, בוחרים באפשרות Replace ולוחצים על Add Rule.
בוחרים באפשרות בהתאמה אישית ולוחצים על אישור.
בשדה ערך מותאם אישית, מזינים under:projects/<var>KMS_PROJECT_ID</var>.
לוחצים על סיום ואז על שמירה.

gcloud

  gcloud resource-manager org-policies --project=PROJECT_ID \
    allow gcp.restrictCmekCryptoKeyProjects under:projects/KMS_PROJECT_ID

כדי לוודא שהמדיניות הוחלה בהצלחה, אתם יכולים לנסות ליצור טבלה באמצעות מפתח Cloud KMS מפרויקט אחר. התהליך ייכשל.

מגבלות של מדיניות הארגון

יש מגבלות שקשורות להגדרת מדיניות הארגון.

עיכוב בהפצה

אחרי שמגדירים או מעדכנים את מדיניות הארגון, יכול להיות שיחלפו עד 15 דקות עד שהמדיניות החדשה תיכנס לתוקף. כדי לא להשפיע לרעה על זמן האחזור של יצירת שאילתות וטבלאות, המערכת שומרת את כללי המדיניות במטמון של BigQuery.

ההרשאות שנדרשות כדי להגדיר את מדיניות הארגון

יכול להיות שיהיה קשה לקבל את ההרשאה להגדיר או לעדכן את מדיניות הארגון למטרות בדיקה. צריך להיות לכם את התפקיד אדמין של מדיניות הארגון, שאפשר לתת רק ברמת הארגון (ולא ברמת הפרויקט או התיקייה).

למרות שצריך להקצות את התפקיד ברמת הארגון, עדיין אפשר לציין מדיניות שחלה רק על פרויקט או תיקייה ספציפיים.

ההשפעה של רוטציית מפתחות ב-Cloud KMS

‫BigQuery לא מבצע רוטציה אוטומטית למפתח הצפנה של טבלה כשמתבצעת רוטציה של מפתח Cloud KMS שמשויך לטבלה. כל הנתונים בטבלאות הקיימות ממשיכים להיות מוגנים באמצעות גרסת המפתח שבאמצעותה הן נוצרו.

כדי לעדכן טבלה כך שתשתמש בגרסת המפתח העדכנית ביותר, מעדכנים את הטבלה עם אותו מפתח Cloud KMS. העדכון הזה לא יבדוק את מדיניות הארגון. רק עדכון של המפתח יבדוק את מדיניות הארגון.

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

ההשפעה על החיוב ב-Cloud KMS

כשיוצרים או חותכים טבלה שמוגנת באמצעות CMEK, ‏BigQuery יוצר מפתח ביניים להצפנת מפתחות (KEK) שמוצפן באמצעות מפתח Cloud KMS שצוין.

למטרות חיוב, המשמעות היא שהקריאות ל-Cloud KMS והעלויות שמשויכות אליהן לא משתנות בהתאם לגודל הטבלה. בטבלאות שמוגנות באמצעות CMEK, צפויה קריאה אחת ל-Cloud KMS cryptoKeys.encrypt לכל יצירה או חיתוך של טבלה, וקריאה אחת ל-Cloud KMS cryptoKeys.decrypt לכל טבלה שמעורבת בשאילתה. שתי השיטות האלה שייכות לקטגוריה פעולות במפתחות: קריפטוגרפיות שמופיעה במאמר התמחור של Cloud KMS.

קריאה מטבלה קיימת שמוגנת באמצעות CMEK או כתיבה אליה מפעילה את Cloud KMS cryptoKeys.decrypt, כי צריך לפענח את מפתח הביניים.

מגבלות

גישה של BigQuery למפתח Cloud KMS

מפתח Cloud KMS נחשב לזמין ונגיש ל-BigQuery בתנאים הבאים:

המפתח מופעל
לחשבון השירות של BigQuery יש הרשאות הצפנה ופענוח במפתח.

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

ההשפעה על הזנת זרם נתונים

המפתח של Cloud KMS צריך להיות זמין ונגיש למשך 24 שעות רצופות לפחות, בפרק הזמן של 48 שעות אחרי בקשה להזנת זרם נתונים. אם המפתח לא זמין ונגיש, יכול להיות שהנתונים שמועברים בסטרימינג לא יישמרו באופן מלא וילכו לאיבוד. למידע נוסף על הזנת זרם נתונים, קראו את המאמר הזרמת נתונים ל-BigQuery.

ההשפעה על נתונים שלא נגישים לטווח הארוך

מכיוון ש-BigQuery מספק אחסון מנוהל, נתונים שלא נגישים לטווח ארוך לא תואמים לארכיטקטורה של BigQuery. אם מפתח Cloud KMS של טבלה מסוימת ב-BigQuery לא זמין ואין אליו גישה במשך 60 ימים רצופים, יכול להיות שהטבלה והנתונים שמשויכים אליה יימחקו מ-BigQuery. לפחות 7 ימים לפני מחיקת הנתונים, נשלחת הודעה מ-BigQuery לכתובת האימייל שמשויכת לחשבון לחיוב.

שימוש במקורות נתונים חיצוניים

אם אתם שולחים שאילתות לנתונים שמאוחסנים במקור נתונים חיצוני כמו Cloud Storage, שכולל נתונים שמוצפנים באמצעות CMEK, הצפנת הנתונים מנוהלת על ידי Cloud Storage. לדוגמה, טבלאות BigLake תומכות בנתונים שמוצפנים באמצעות CMEK ב-Cloud Storage.

בטבלאות BigQuery ו-BigLake אי אפשר להשתמש במפתחות הצפנה באספקת הלקוח (CSEK).

מעבר בין הצפנה שמוגנת באמצעות CMEK לבין הצפנה שמוגדרת כברירת מחדל

אי אפשר להחליף טבלה קיימת בין הצפנות ברירת מחדל לבין הצפנת CMEK. כדי להחליף את ההצפנה, מעתיקים את הטבלה עם הגדרת פרטי ההצפנה של היעד, או משתמשים בשאילתת SELECT * כדי לבחור את הטבלה לתוך עצמה עם מאפיין WRITE_TRUNCATE.

שימוש במעצבי טבלאות

אם אתם מגנים על טבלה באמצעות Cloud KMS ואז מחליפים את הנתונים בטבלה באמצעות הערך WRITE_TRUNCATE לפעולה load, cp או query, מעצבי טווח לא פועלים מעבר לגבולות השינוי בהצפנה. עדיין אפשר להשתמש במעצבי טבלאות, כולל מעצבי טווחים, כדי לשלוח שאילתות על הנתונים לפני או אחרי הגבול, או לשלוח שאילתות על תמונת המצב בנקודת זמן מסוימת.

שאילתות בטבלאות עם תווים כלליים לחיפוש

אי אפשר לשלוח שאילתות לטבלאות שמוגנות באמצעות CMEK עם סיומת של תו כללי לחיפוש.

תמיכה בסקריפטים

בסקריפטים אי אפשר להגדיר טבלאות יעד לפעולות CMEK.

תמיכה במהדורות

התמיכה של CMEK ב-BigQuery זמינה רק ב-BigQuery Enterprise, ב-BigQuery Enterprise Plus וב-BigQuery On-Demand.

תמיכה ב-BigQuery Studio

נכסי הקוד של BigQuery Studio תומכים ב-CMEK. נכסי קוד כוללים את הדברים הבאים:

מידע נוסף זמין במאמר שימוש ב-CMEK כדי להגן על נכסי קוד ב-BigQuery Studio.

שאלות נפוצות

מי צריך הרשאה למפתח Cloud KMS?

כשמשתמשים במפתחות הצפנה בניהול הלקוח, לא צריך לציין הרשאות שוב ושוב. כל עוד לחשבון השירות של BigQuery יש הרשאה להשתמש במפתח Cloud KMS כדי להצפין ולפענח, כל מי שיש לו הרשאה לטבלה ב-BigQuery יכול לגשת לנתונים, גם אם אין לו גישה ישירה למפתח Cloud KMS.

באיזה חשבון שירות משתמשים?

חשבון השירות של BigQuery שמשויך לפרויקטGoogle Cloud של הטבלה משמש לפענוח הנתונים של הטבלה. חשבונות השירות של BigQuery הם ייחודיים לכל פרויקט. במשימה שכותבת נתונים לטבלה אנונימית שמוגנת באמצעות Cloud KMS, נעשה שימוש בחשבון השירות של הפרויקט של המשימה.

לדוגמה, נניח שיש שלוש טבלאות שמוגנות באמצעות CMEK: ‏table1,‏ table2 ו-table3. כדי להריץ שאילתה על נתונים מ-{project1.table1, project2.table2} עם טבלת היעד {project3.table3}:

שימוש בחשבון השירות project1 בשביל project1.table1
שימוש בחשבון השירות project2 בשביל project2.table2
שימוש בחשבון השירות project3 בשביל project3.table3

איך BigQuery יכול להשתמש במפתח Cloud KMS שלי?

‫BigQuery משתמש במפתח Cloud KMS כדי לפענח נתונים בתגובה לשאילתת משתמש, לדוגמה, tabledata.list או jobs.insert.

בנוסף, BigQuery יכול להשתמש במפתח למשימות של תחזוקת נתונים ואופטימיזציה של האחסון, כמו המרת נתונים לפורמט שמותאם לקריאה.

באילו ספריות קריפטוגרפיה משתמשים?

‫BigQuery מסתמך על Cloud KMS לפונקציונליות של CMEK. ‫Cloud KMS משתמש ב-Tink להצפנה.

איך אפשר לקבל עזרה נוספת?

אם יש לכם שאלות שלא נענו כאן, תוכלו להיעזר בתמיכה של BigQuery.

פתרון בעיות

ברשימה הבאה מתוארות שגיאות נפוצות והפתרונות המומלצים כשמשתמשים במפתחות הצפנה בניהול הלקוח (CMEK) עם Cloud Key Management Service:

שגיאה: Please grant Cloud KMS CryptoKey Encrypter/Decrypter role: פתרון: לחשבון השירות של BigQuery שמשויך לפרויקט אין מספיק הרשאות IAM כדי לפעול במפתח Cloud KMS שצוין. כדי להעניק את הרשאת ה-IAM הנדרשת, פועלים לפי ההוראות שבהודעת השגיאה או בקטע מתן הרשאת הצפנה ופענוח.
שגיאה: Existing table encryption settings don't match encryption settings specified in the request: פתרון: השגיאה הזו יכולה לקרות כשהגדרות ההצפנה של טבלת היעד לא תואמות להגדרות ההצפנה בבקשה. כדי לפתור את הבעיה, צריך להשתמש ב-write disposition של TRUNCATE כדי להחליף את הטבלה, או לציין טבלת יעד אחרת.
שגיאה: This region is not supported: פתרון: האזור של מפתח Cloud KMS לא תואם לאזור של מערך הנתונים ב-BigQuery של טבלת היעד. כדי לפתור את הבעיה, צריך לבחור מפתח באזור שתואם למערך הנתונים, או לטעון נתונים למערך נתונים שתואם לאזור של המפתח.
שגיאה: Your administrator requires that you specify an encryption key for queries in project PROJECT_ID.: פתרון: מדיניות הארגון מנעה יצירת משאב או הרצת שאילתה. מידע נוסף על המדיניות הזו זמין במאמר דרישה לשימוש במפתחות CMEK בכל המשאבים.
שגיאה: Your administrator prevents using KMS keys from project KMS_PROJECT_ID to protect resources in project PROJECT_ID.: פתרון: מדיניות הארגון מנעה יצירת משאב או הרצת שאילתה. מידע נוסף על המדיניות הזו זמין במאמר הגבלת מפתחות Cloud KMS לפרויקט BigQuery.