מפתחות 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.iam.gserviceaccount.com

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

המסוף

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

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

BQ

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

bq show --encryption_service_account

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

                  ServiceAccountID
-------------------------------------------------------------
bq-PROJECT_NUMBER@bigquery-encryption.iam.gserviceaccount.com

הקצאת התפקיד Encrypter/Decrypter

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

bq-PROJECT_NUMBER@bigquery-encryption.iam.gserviceaccount.com

המסוף

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

gcloud

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

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

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

‫KMS_PROJECT_ID: המזהה של הפרויקט שבו פועל Cloud KMS Google Cloud
‫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

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

פותחים את הדף Cryptographic Keys במסוף Google Cloud .
פתיחה של הדף Cryptographic Keys (מפתחות הצפנה)
לוחצים על השם של אוסף המפתחות שמכיל את המפתח.
למפתח שרוצים לאחזר את מזהה המשאב שלו, לוחצים על עוד .
לוחצים על העתקת שם המשאב. מזהה המשאב של המפתח מועתק ללוח. מזהה המשאב נקרא גם שם המשאב.

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

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

המסוף

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

לדף BigQuery
בחלונית הימנית, לוחצים על כלי הניתוחים:

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

SQL

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

במסוף Google Cloud , עוברים לדף BigQuery.

כניסה ל-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.
מגדירים את פרויקט ברירת המחדל שבו רוצים להחיל את ההגדרות של Terraform. Google Cloud

תצטרכו להריץ את הפקודה הזו רק פעם אחת לכל פרויקט, ותוכלו לעשות זאת בכל ספרייה.
```
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

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

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

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

המסוף

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

לדף BigQuery
לוחצים על Compose new query (כתיבת שאילתה חדשה).
מזינים שאילתת GoogleSQL תקינה באזור הטקסט של השאילתה.
לוחצים על עוד, על הגדרות שאילתה ואז על אפשרויות מתקדמות.
בוחרים באפשרות הצפנה בניהול הלקוח.
בוחרים את המפתח. אם המפתח שרוצים להשתמש בו לא מופיע ברשימה, מזינים את מזהה המשאב של המפתח.
לוחצים על 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.

Go

כדי לבצע אימות ב-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, מרחיבים את הפרויקט, לוחצים על Datasets ואז לוחצים על מערך נתונים. מערך הנתונים ייפתח בכרטיסייה.
בחלונית הפרטים, לוחצים על יצירת טבלה.
מזינים את האפשרויות שרוצים להשתמש בהן לטעינת הטבלה, אבל לפני שלוחצים על יצירת טבלה, לוחצים על אפשרויות מתקדמות.
בקטע הצפנה, בוחרים באפשרות מפתח בניהול הלקוח.
לוחצים על הרשימה הנפתחת בחירת מפתח בניהול הלקוח ובוחרים את המפתח שרוצים להשתמש בו. אם לא מופיעים מפתחות זמינים, מזינים מזהה משאב מפתח.
לוחצים על יצירת טבלה.

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

Go

כדי לבצע אימות ב-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.

שינוי טבלה מהצפנה שמוגדרת כברירת מחדל להגנה באמצעות 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.

Go

כדי לבצע אימות ב-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, בשדה מפתח הצפנה בניהול הלקוח מוצג מזהה משאב המפתח.

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

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

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

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

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

יתרון של update הוא שהוא מהיר יותר מ-cp, ואפשר להשתמש בו במעצבי טבלאות.

SQL

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

במסוף Google Cloud , עוברים לדף BigQuery.

כניסה ל-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

Go

כדי לבצע אימות ב-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 אחר כשתיצרו את הטבלה. מפתח ברירת המחדל לא חל על טבלאות קיימות. שינוי מפתח ברירת המחדל לא משנה טבלאות קיימות, והוא חל רק על טבלאות חדשות שנוצרו אחרי השינוי.

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

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

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

bq mk \
--default_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
--dataset DATASET_ID

bq update \
--default_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
--dataset DATASET_ID

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

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

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

SQL

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

במסוף Google Cloud , עוברים לדף BigQuery.

כניסה ל-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 מופיעים בשדה מפתח בניהול הלקוח בקטע פרטי המודל בחלונית פרטים של המודל.

שינוי מפתח 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, אפשר להשתמש ב-CMEK כדי להגן על פרטי הכניסה של BigQuery Connection API.

מידע נוסף על יצירת חיבור שמוגן באמצעות 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.

אי אפשר להגדיר את תצורת ברירת המחדל של CMEK ב-Dataform לנכסי קוד ב-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 ימשיכו להתקיים ותהיה אליהם גישה ללא בעיות.

המסוף

פותחים את הדף מדיניות הארגון.

מעבר אל מדיניות הארגון
בשדה Filter (מסנן), מזינים constraints/gcp.restrictNonCmekServices ולוחצים על Restrict which services may create resources without CMEK (הגבלת השירותים שיכולים ליצור משאבים ללא 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".

המסוף

פותחים את הדף מדיניות הארגון.

מעבר אל מדיניות הארגון
בשדה 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 יוצר מפתח ביניים להצפנת מפתחות, שמוצפן באמצעות מפתח 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 disposition.

שימוש ב-table decorators

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

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

אי אפשר להריץ שאילתות על טבלאות שמוגנות באמצעות CMEK עם סיומת של wildcard.

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

סקריפטים לא יכולים להגדיר טבלאות יעד לפעולות 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

באילו דרכים אפשר להשתמש במפתח Cloud KMS ב-BigQuery?

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

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

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

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

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

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

פתרון לשגיאות

בהמשך מתוארות שגיאות נפוצות ומומלצים פתרונות לבעיות שגורמות להן.

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