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

מפתחות 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

הקצאת התפקיד 'הצפנה/פענוח'

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

המשך

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

המשך

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

המשך

כדי לבצע אימות ב-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 וכלי שורת הפקודה bq: ‏ update או cp.

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

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

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

SQL

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

במסוף 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

המשך

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

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

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

כדי לעדכן את השדה 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 ימשיכו להתקיים ותהיה אליהם גישה ללא בעיות.

המסוף

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

מעבר למדיניות הארגון
בשדה מסנן, מזינים constraints/gcp.restrictNonCmekServices ולוחצים על הגבלת השירותים שיכולים ליצור משאבים ללא 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.

שימוש בקווי הפרדה בטבלה

אם מגנים על טבלה באמצעות 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.