---
title: CMEK用にGoogle Cloud KMSを設定する
url: https://platform.claude.com/docs/ja/manage-claude/cmek-google-cloud-kms
description: Google Cloud KMSを使用して、組織の暗号化キーを提供します。
---

Claude Codeにこの機能を設定させる

```text
/claude-api Google Cloud KMSで顧客管理暗号化キーを設定するのを手伝ってください
```

このガイドでは、Anthropic組織の[顧客管理暗号化キー（CMEK）](https://platform.claude.com/docs/ja/manage-claude/cmek)としてGoogle Cloud KMSキーを設定する手順を説明します。

<Warning>
  CMEKの有効化は永続的です。KMSキーが削除または無効化された場合、Anthropicはそのキーで暗号化されたデータを復元できません。開始する前に[警告と制限事項](https://platform.claude.com/docs/ja/manage-claude/cmek)を確認してください。
</Warning>

## 前提条件

* 請求が有効になっているGoogle Cloudプロジェクト。
* Cloud KMS APIが有効になっていること（`cloudkms.googleapis.com`）。
* KMSキーリングとキーを作成し、それらにIAMポリシーを設定する権限（`roles/cloudkms.admin`または同等のもの）。
* 組織のAnthropic Admin APIキー。
* [`gcloud` CLI](https://cloud.google.com/cli)がインストールされ、認証されていること。
* プロジェクトに対してCloud KMSの**データアクセス監査ログ**が有効になっていること（IAMと管理 > 監査ログ > Cloud Key Management Service、`DATA_READ`および`DATA_WRITE`付き）。これらはデフォルトでオフになっています。これらがないと、Anthropicの暗号化および復号化操作はCloud Loggingにエントリを生成しません。

## Anthropicサービスアカウントのメールアドレス

Anthropicに暗号化キーを使用させるには、Anthropicのサービスアカウントにデータの暗号化に使用できるキーを付与する必要があります。Anthropic CMEKのサービスアカウントのメールアドレスは次のとおりです。

```text wrap
anthropic-cmek-client-us@gcp-anthropic-cmek-clients.iam.gserviceaccount.com
```

<Warning>
  この公開されたサービスアカウントのメールアドレスのみを使用してください。メール、チャット、またはオンボーディングチャネルで提供された識別子を決して信頼しないでください。
</Warning>

<Note>
  **ドメイン制限共有:** プロジェクトが`constraints/iam.allowedPolicyMemberDomains`を適用するGoogle Cloud組織の下にある場合、Anthropicサービスアカウントが組織外にあるため、以下のIAMバインディングは拒否されます。その制約に対するプロジェクトレベルの除外設定を行うか、AnthropicのCloud Identity顧客ID（形式`C0xxxxxxxx`）を許可リストに追加する必要があります。必要に応じて顧客IDについてAnthropicにお問い合わせください。
</Note>

## 暗号化キーのセットアップ

<Steps>
  <Step title="キーリングを作成または選択する">
    再利用するキーリングがすでにある場合は、このステップをスキップしてください。キーリングはリージョン単位です。設定しているAnthropicの地域に一致する`us-east5`などの単一リージョンのUSロケーションを選択してください。`us`や`global`などのマルチリージョンロケーションはサポートされていません。

    ```bash
    gcloud kms keyrings create <your-keyring-name> \
      --project=<your-project-id> \
      --location=<region>
    ```
  </Step>

  <Step title="暗号鍵を作成する">
    `ENCRYPT_DECRYPT`の目的で対称鍵を作成します。AnthropicはHSM保護を強く推奨します。Cloud KMS HSMキーはFIPS 140-2 Level 3検証済みであり、ソフトウェアキーとのコスト差はわずかです。

    `--labels`オプションは、組織ラベル`anthropic-org-<ORGANIZATION_UUID>`を値`true`で追加します。ここで`<ORGANIZATION_UUID>`は小文字のAnthropic組織IDです。このラベルはAnthropicがキーを検証するために必要です。

    <Note>
      **組織IDの確認方法:** Claude Consoleの[Organization](https://platform.claude.com/settings/organization)ページ（`platform.claude.com/settings/organization`）、またはclaude.aiの**Organization settings > Organization**にある**Organization ID**フィールドをコピーするか、[Organization Info](https://platform.claude.com/docs/ja/api/organization/retrieve)エンドポイントから`id`フィールドを読み取ってください。`org_`プレフィックス付きのIDではなく、UUIDのみを使用してください。
    </Note>

    ```bash
    gcloud kms keys create <KEY_NAME> \
      --project=<PROJECT_ID> \
      --location=<REGION> \
      --keyring=<KEYRING_NAME> \
      --purpose=encryption \
      --protection-level=hsm \
      --labels=anthropic-org-<ORGANIZATION_UUID>=true
    ```

    代わりにソフトウェア保護を使用する場合は、`--protection-level=hsm`を省略してください。このガイドの他の部分は変わりません。

    Google Cloud Consoleからキーを作成することもできます。キーリングを開き、**Create key**をクリックし、**Generated key**を選択し、目的とアルゴリズムを対称暗号化および復号化に設定し、保護レベルで**HSM**を選択します。

    <Frame caption="組織ラベル付きのHSM保護された対称暗号化/復号化キー（symmetric encrypt/decrypt key）を作成します。">
      ![Google Cloud KMSのCreate keyページ。HSM保護と対称暗号化/復号化が選択され、anthropic-orgラベルがtrueに設定されています。](https://platform.claude.com/docs/images/cmek/gcp-create-key-label.png)
    </Frame>

    複数のAnthropic組織間で1つのキーを共有するには、各組織に対してそのようなラベルを1つ追加します。キーは、自分のものを含めて最大64個のラベルを持つことができます。

    <Note>
      ラベルを持たないキーにラベルを追加するには、`gcloud kms keys update <KEY_NAME> --project=<PROJECT_ID> --location=<REGION> --keyring=<KEYRING_NAME> --update-labels=anthropic-org-<ORGANIZATION_UUID>=true`を実行します。これにより、キーがすでに持っているラベルとラベルがマージされます。
    </Note>
  </Step>

  <Step title="Anthropicのサービスアカウントにキーへのアクセスを付与する">
    2つのキーレベルのIAMバインディングが必要です。どちらも、プロジェクト全体やキーリング全体ではなく、単一の暗号鍵にスコープされます。

    暗号化と復号化。Anthropicがワークスペースデータを保護するデータキーを暗号化および復号化するために使用します（エンベロープ暗号化）。

    ```bash
    gcloud kms keys add-iam-policy-binding <your-key-name> \
      --project=<your-project-id> \
      --location=<region> \
      --keyring=<your-keyring-name> \
      --member="serviceAccount:anthropic-cmek-client-us@gcp-anthropic-cmek-clients.iam.gserviceaccount.com" \
      --role=roles/cloudkms.cryptoKeyEncrypterDecrypter
    ```

    ビューアー。Anthropicがキーの目的とアルゴリズムを検証するために起動時に実行するメタデータ読み取り（`cryptoKeys.get`）用です。

    ```bash
    gcloud kms keys add-iam-policy-binding <your-key-name> \
      --project=<your-project-id> \
      --location=<region> \
      --keyring=<your-keyring-name> \
      --member="serviceAccount:anthropic-cmek-client-us@gcp-anthropic-cmek-clients.iam.gserviceaccount.com" \
      --role=roles/cloudkms.viewer
    ```

    Consoleから、キーを選択し、**Permissions**パネルを開き、**Grant access**をクリックし、Cloud KMS CryptoKey Encrypter/DecrypterとCloud KMS Viewerの両方のロールでサービスアカウントを追加します。付与がこのキーのみにスコープされるように、キーリングやプロジェクトではなく、キーの権限ページにいることを確認してください。

    <Frame caption="Anthropicサービスアカウントに両方のロールを付与し、キーにスコープします。">
      ![Grant accessダイアログ。AnthropicサービスアカウントにCloud KMS CryptoKey Encrypter/DecrypterロールとViewerロールが割り当てられています。](https://platform.claude.com/docs/images/cmek/gcp-grant-access.png)
    </Frame>
  </Step>

  <Step title="完全なキーリソース名を記録する">
    キーを登録する際にこれをAnthropicに渡します。形式は次のとおりです。

    ```text wrap
    projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>
    ```

    次のコマンドで取得します。

    ```bash
    gcloud kms keys describe <your-key-name> \
      --project=<your-project-id> \
      --location=<region> \
      --keyring=<your-keyring-name> \
      --format="value(name)"
    ```

    Consoleから、キーの詳細ページを開き、**Copy resource name**をクリックします。

    <Frame caption="アクションメニューからキーの完全なリソース名（full resource name）をコピーします。">
      ![Google Cloudのキーリングの詳細。キーのアクションメニューでCopy resource nameアクションがハイライトされています。](https://platform.claude.com/docs/images/cmek/gcp-copy-resource-name.png)
    </Frame>
  </Step>
</Steps>

## Anthropicにキーを登録する

キーの登録方法は、使用する製品によって異なります。

<Tabs>
  <Tab title="Claude Platform">
    Claude ConsoleまたはAdmin APIを通じてキーをセットアップでき、結果は同じです。

    <Tabs>
      <Tab title="Claude Console">
        <Steps>
          <Step title="Anthropicにキーを登録する">
            Claude Consoleで、[Data retention](https://platform.claude.com/settings/privacy#encryption-keys)ページ（`platform.claude.com/settings/privacy`）に移動します。**Encryption keys**が表示されない場合は、ページ上部のドロップダウンメニューから**Organization**を選択してください。**Encryption keys**の下で**Add key**をクリックします。表示名を入力し、**Google Cloud KMS**を選択して**Continue**をクリックします。完全なキーリソース名を**Key resource name**に貼り付け、**Add**をクリックします。

            キー詳細ステップには組織ラベルが表示されます。**Add**をクリックする前に、[作成ステップ](https://platform.claude.com/docs/ja/manage-claude/cmek-google-cloud-kms#organization-label)で説明されているように、キーにラベルを追加してください。
          </Step>

          <Step title="キーを検証する">
            **Encryption keys**リストで、キーの横にある**Verify**をクリックします。チェックに合格すると**Connected**と表示されます。失敗した場合は、メッセージに理由が表示されます。
          </Step>

          <Step title="キーをワークスペースにアタッチする">
            Claude Consoleで、[Data retention](https://platform.claude.com/settings/privacy)ページ（`platform.claude.com/settings/privacy`）に移動し、ページ上部のドロップダウンメニューからワークスペースを選択します。**Encryption key**の下でキーを選択し、**Save**をクリックして確認します。キーのアタッチは元に戻せません。すでにリクエストを受信しているワークスペースの場合、キーが[有効になるまで最大1日かかる](https://platform.claude.com/docs/ja/manage-claude/cmek#how-it-works)ことがあります。
          </Step>
        </Steps>
      </Tab>

      <Tab title="API">
        <Steps>
          <Step title="Anthropicにキーを登録する">
            暗号化キーのセットアップの下にある「完全なキーリソース名を記録する」ステップのリソース名を使用して、Admin APIを通じて外部キー設定を作成します。

            <CodeGroup>
              ```bash cURL
              curl -sS "https://api.anthropic.com/v1/organizations/external_keys" \
                -H "x-api-key: $ANTHROPIC_API_KEY" \
                -H "anthropic-version: 2023-06-01" \
                -H "content-type: application/json" \
                -d '{
                  "display_name": "<friendly-name>",
                  "geo": "us",
                  "provider_config": {
                    "type": "gcp",
                    "key_name": "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
                  }
                }'
              ```

              ```bash CLI
              ant organization:external-keys create <<'YAML'
              display_name: "<friendly-name>"
              geo: us
              provider_config:
                type: gcp
                key_name: "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
              YAML
              ```

              ```python Python
              client = anthropic.Anthropic()

              external_key = client.organization.external_keys.create(
                  display_name="<friendly-name>",
                  geo="us",
                  provider_config={
                      "type": "gcp",
                      "key_name": "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>",
                  },
              )

              print(f"id: {external_key.id}")
              print(f"display_name: {external_key.display_name}")
              ```

              ```typescript TypeScript
              const client = new Anthropic();

              const externalKey = await client.organization.externalKeys.create({
                display_name: "<friendly-name>",
                geo: "us",
                provider_config: {
                  type: "gcp",
                  key_name:
                    "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
                }
              });

              console.log(`id: ${externalKey.id}`);
              console.log(`display_name: ${externalKey.display_name}`);
              ```

              ```csharp C#
              using Anthropic.Models.Organization.ExternalKeys;

              AnthropicClient client = new();

              var externalKey = await client.Organization.ExternalKeys.Create(new()
              {
                  DisplayName = "<friendly-name>",
                  Geo = Geo.Us,
                  ProviderConfig = new GcpExternalKeyConfig
                  {
                      KeyName = "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
                  }
              });

              Console.WriteLine($"id: {externalKey.ID}");
              Console.WriteLine($"display_name: {externalKey.DisplayName}");
              ```

              ```go Go
              client := anthropic.NewClient()

              externalKey, err := client.Organization.ExternalKeys.New(context.Background(), anthropic.OrganizationExternalKeyNewParams{
              	DisplayName: anthropic.String("<friendly-name>"),
              	Geo:         anthropic.OrganizationExternalKeyNewParamsGeoUs,
              	ProviderConfig: anthropic.OrganizationExternalKeyNewParamsProviderConfigUnion{
              		OfGCP: &anthropic.GCPExternalKeyConfigParam{
              			KeyName: "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>",
              		},
              	},
              })
              if err != nil {
              	log.Fatal(err)
              }

              fmt.Printf("id: %s\n", externalKey.ID)
              fmt.Printf("display_name: %s\n", externalKey.DisplayName)
              ```

              ```java Java
              import com.anthropic.models.organization.externalkeys.ExternalKeyCreateParams;

              void main() {
                  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

                  var params = ExternalKeyCreateParams.builder()
                      .displayName("<friendly-name>")
                      .geo(ExternalKeyCreateParams.Geo.US)
                      .gcpProviderConfig("projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>")
                      .build();
                  var externalKey = client.organization().externalKeys().create(params);

                  IO.println("id: " + externalKey.id());
                  IO.println("display_name: " + externalKey.displayName().orElseThrow());
              }
              ```

              ```php PHP
              use Anthropic\Organization\ExternalKeys\ExternalKeyCreateParams\Geo;
              // ...

              $client = new Client();

              $externalKey = $client->organization->externalKeys->create(
                  displayName: '<friendly-name>',
                  geo: Geo::US,
                  providerConfig: [
                      'type' => 'gcp',
                      'keyName' => 'projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>',
                  ],
              );

              echo "id: {$externalKey->id}\n";
              echo "display_name: {$externalKey->displayName}\n";
              ```

              ```ruby Ruby
              client = Anthropic::Client.new

              external_key = client.organization.external_keys.create(
                display_name: "<friendly-name>",
                geo: :us,
                provider_config: {
                  type: :gcp,
                  key_name: "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
                }
              )

              puts "id: #{external_key.id}"
              puts "display_name: #{external_key.display_name}"
              ```
            </CodeGroup>

            レスポンスには外部キーIDが含まれます。

            ```json
            {
              "type": "external_key",
              "id": "ekey_<id>",
              "display_name": "<friendly-name>"
            }
            ```
          </Step>

          <Step title="キーを検証する">
            キーに対して暗号化と復号化のラウンドトリップをトリガーします。

            <CodeGroup>
              ```bash cURL
              curl -sS -X POST "https://api.anthropic.com/v1/organizations/external_keys/ekey_<id>/validate" \
                -H "x-api-key: $ANTHROPIC_API_KEY" \
                -H "anthropic-version: 2023-06-01"
              ```

              ```bash CLI
              ant organization:external-keys validate --external-key-id "ekey_<id>"
              ```

              ```python Python
              client = anthropic.Anthropic()

              validation = client.organization.external_keys.validate("ekey_<id>")

              print(f"status: {validation.status}")
              print(f"error: {validation.error}")
              ```

              ```typescript TypeScript
              const client = new Anthropic();

              const validation = await client.organization.externalKeys.validate("ekey_<id>");

              console.log(`status: ${validation.status}`);
              console.log(`error: ${validation.error}`);
              ```

              ```csharp C#
              AnthropicClient client = new();

              var validation = await client.Organization.ExternalKeys.Validate("ekey_<id>");

              Console.WriteLine($"status: {validation.Status.Raw()}");
              Console.WriteLine($"error: {validation.Error}");
              ```

              ```go Go
              client := anthropic.NewClient()

              validation, err := client.Organization.ExternalKeys.Validate(context.Background(), "ekey_<id>")
              if err != nil {
              	log.Fatal(err)
              }

              fmt.Printf("status: %s\n", validation.Status)
              fmt.Printf("error: %s\n", validation.Error)
              ```

              ```java Java
              AnthropicClient client = AnthropicOkHttpClient.fromEnv();

              var validation = client.organization().externalKeys().validate("ekey_<id>");

              IO.println("status: " + validation.status().asString());
              IO.println("error: " + validation.error().orElse(""));
              ```

              ```php PHP
              $client = new Client();

              $validation = $client->organization->externalKeys->validate(
                  externalKeyID: 'ekey_<id>',
              );

              echo "status: {$validation->status}\n";
              echo "error: {$validation->error}\n";
              ```

              ```ruby Ruby
              client = Anthropic::Client.new

              external_key_id = "ekey_<id>"
              validation = client.organization.external_keys.validate(external_key_id)

              puts "status: #{validation.status}"
              puts "error: #{validation.error}"
              ```
            </CodeGroup>

            成功したレスポンスは次のようになります。

            ```json
            { "type": "external_key_validation", "status": "success", "error": null }
            ```

            検証が失敗した場合、一般的な原因は次のとおりです。

            * **VPC Service Controls:** サービス境界がプロジェクト内のCloud KMSを保護している場合、Anthropicがキーに到達できるように、境界のアクセスレベルにAnthropicを追加します（またはキーのプロジェクトを除外します）。
            * **ドメイン制限共有:** `constraints/iam.allowedPolicyMemberDomains`組織ポリシーがAnthropicサービスアカウントのバインディングを削除する可能性があります（前述の注記を参照）。`gcloud kms keys get-iam-policy <your-key-name> --project=<your-project-id> --location=<region> --keyring=<your-keyring-name>`でバインディングが存在することを確認してください。
            * **無効化または破棄されたキーバージョン:** キーのプライマリバージョンが有効であり、無効化、破棄予定、または破棄されていないことを確認してください。
          </Step>

          <Step title="キーをワークスペースにアタッチする">
            キーが検証されたら、そのワークスペースにリクエストを送信する前に、新しいワークスペースにアタッチします。すでにリクエストを受信しているワークスペースの場合、キーが[有効になるまで最大1日かかる](https://platform.claude.com/docs/ja/manage-claude/cmek#how-it-works)ことがあります。

            <CodeGroup>
              ```bash cURL
              curl -sS -X POST "https://api.anthropic.com/v1/organizations/workspaces/<workspace-id>" \
                -H "x-api-key: $ANTHROPIC_API_KEY" \
                -H "anthropic-version: 2023-06-01" \
                -H "content-type: application/json" \
                -d '{
                  "external_key_id": "ekey_<id>"
                }'
              ```

              ```bash CLI
              ant organization:workspaces update \
                --workspace-id "<workspace-id>" \
                --external-key-id "ekey_<id>"
              ```

              ```python Python
              client = anthropic.Anthropic()

              workspace = client.organization.workspaces.update(
                  "<workspace-id>", external_key_id="ekey_<id>"
              )

              print(f"id: {workspace.id}")
              print(f"external_key_id: {workspace.external_key_id}")
              ```

              ```typescript TypeScript
              const client = new Anthropic();

              const workspace = await client.organization.workspaces.update("<workspace-id>", {
                external_key_id: "ekey_<id>"
              });

              console.log(`id: ${workspace.id}`);
              console.log(`external_key_id: ${workspace.external_key_id}`);
              ```

              ```csharp C#
              AnthropicClient client = new();

              var workspace = await client.Organization.Workspaces.Update("<workspace-id>", new()
              {
                  ExternalKeyID = "ekey_<id>"
              });

              Console.WriteLine($"id: {workspace.ID}");
              Console.WriteLine($"external_key_id: {workspace.ExternalKeyID}");
              ```

              ```go Go
              client := anthropic.NewClient()

              workspace, err := client.Organization.Workspaces.Update(
              	context.Background(),
              	"<workspace-id>",
              	anthropic.OrganizationWorkspaceUpdateParams{
              		ExternalKeyID: anthropic.String("ekey_<id>"),
              	},
              )
              if err != nil {
              	log.Fatal(err)
              }

              fmt.Printf("id: %s\n", workspace.ID)
              fmt.Printf("external_key_id: %s\n", workspace.ExternalKeyID)
              ```

              ```java Java
              import com.anthropic.models.organization.workspaces.WorkspaceUpdateParams;

              void main() {
                  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

                  var params = WorkspaceUpdateParams.builder()
                      .externalKeyId("ekey_<id>")
                      .build();
                  var workspace = client.organization().workspaces().update("<workspace-id>", params);

                  IO.println("id: " + workspace.id());
                  IO.println("external_key_id: " + workspace.externalKeyId().orElseThrow());
              }
              ```

              ```php PHP
              $client = new Client();

              $workspace = $client->organization->workspaces->update(
                  workspaceID: '<workspace-id>',
                  externalKeyID: 'ekey_<id>',
              );

              echo "id: {$workspace->id}\n";
              echo "external_key_id: {$workspace->externalKeyID}\n";
              ```

              ```ruby Ruby
              client = Anthropic::Client.new

              workspace_id = "<workspace-id>"
              workspace = client.organization.workspaces.update(
                workspace_id,
                external_key_id: "ekey_<id>"
              )

              puts "id: #{workspace.id}"
              puts "external_key_id: #{workspace.external_key_id}"
              ```
            </CodeGroup>
          </Step>
        </Steps>
      </Tab>
    </Tabs>
  </Tab>

  <Tab title="Claude Enterprise">
    [claude.ai > Organization settings > Data and privacy](https://claude.ai/admin-settings/data-privacy-controls)で、**Encryption keys**を開き、**Add key**をクリックします。**Google Cloud**を選択し、前のステップの完全なキーリソース名を貼り付け、**Continue**をクリックします。Anthropicは暗号化と復号化のラウンドトリップでキーを検証します。検証済みと表示されると、その時点以降、組織はCMEKで保護されます。

    Claude Enterpriseでは、CMEKは組織全体に適用されるため、個別のワークスペースアタッチステップはなく、組織は1つのキーのみを持つことができます。
  </Tab>
</Tabs>

## Terraform

Infrastructure-as-codeデプロイメントの場合、同じステップは`google_kms_key_ring`、`google_kms_crypto_key`、および`google_kms_crypto_key_iam_member`リソースを使用して`google`プロバイダーにマッピングされます。
