
Google Cloud Platform (GCP) は単なるサービスの集合体ではありません。それは、Googleが数十年にわたる地球規模での運用を通じて洗練させてきた、Googleの内部インフラストラクチャが外部に公開されたものです。この基本的なメンタルモデルを理解することは、回復力があり、高性能で、コスト最適化されたエンタープライズソリューションを設計するために不可欠です。
Estimate on-demand TB pricing & compute slots before querying
Calculate BigQuery query costs across regions, partition pruning savings, and slot-hour commitments before running expensive analytical warehouse queries.
Google Cloudの差別化の中核にあるのは、Jupiter fabricとよく呼ばれるグローバルなプライベートネットワークです。これはパブリックインターネットではなく、専用の、高帯域幅、低遅延の国際ネットワークです。
| 機能 | 説明 | 影響 |
|---|---|---|
| Jupiter Fabric | Googleのプライベートなソフトウェア定義ネットワーク(SDN)で、すべてのデータセンターをグローバルに接続します。 | 予測可能なパフォーマンス、リージョン間トラフィックの遅延削減。 |
| 1 Pbps Bisection Bandwidth | ネットワークの任意の2つの半分間でトラフィックを伝送する総容量。 | 最も要求の厳しいワークロードでもネットワークがボトルネックになることを排除。 |
| Andromeda SDN | VPC、ロードバランシング、ネットワークサービスを支えるネットワーク仮想化スタック。 | 高度なネットワーク機能、マイクロセグメンテーション、ポリシー適用を可能にします。 |
| Premium Tier | デフォルトのルーティング。トラフィックは最寄りのエッジPoPでGoogleのネットワークに入り、プライベートバックボーンを通過します。 | 最適なパフォーマンス、低遅延、高信頼性。ほとんどのプロダクションワークロードに推奨。 |
| Standard Tier | トラフィックは宛先リージョンに近い場所でGoogleのネットワークに入り、パスの大部分でパブリックインターネットを利用します。 | 遅延に敏感でないワークロード向けにコスト最適化されており、エグレス料金が低い。 |
実用的な教訓: プロダクションアプリケーションには常にPremium Tierをデフォルトにしてください。Standard Tierは、開発、テスト、または遅延が重要でない特定のコスト重視のバッチ処理に適しています。パフォーマンスの違いはかなり大きいです。
GCPのリソース階層は、リソースを整理および管理し、ポリシーを適用し、アクセスを制御するための構造化された方法を提供します。これはガバナンスとセキュリティにとって重要なコンポーネントです。
| レベル | 説明 | 主なユースケース |
|---|---|---|
| 組織 | 企業に属するすべてのGoogle Cloudリソースのルートノード。 | 一元化された請求、IAM、ポリシー適用(組織ポリシー)。 |
| フォルダ | 組織の下にプロジェクトをグループ化します。ネスト可能。 | 部門別または環境ベースのグループ化(例: dev、prod)。 |
| プロジェクト | リソースを整理するための基本的な単位。すべてのリソースはプロジェクトに属します。 | 請求、API管理、リソース分離、IAM境界。 |
| リソース | Compute Engineインスタンス、Cloud Storageバケット、BigQueryデータセットなどの個々のサービス。 | 実際のコンピューティング、ストレージ、ネットワーキング、データ資産。 |
IAMポリシーの継承: 上位レベル(例: 組織、フォルダ)で設定されたIAMポリシーは、下位レベルのすべてのリソースに継承されます。これにより、きめ細かな制御とポリシー管理の簡素化が可能になります。
組織の制約(組織ポリシー): これらは、管理者が組織全体でリソースをどのように構成できるかについて制限を定義できる強力なガードレールです。例としては、リソースの場所の制限、外部IPアドレスの無効化、特定のAPI使用の強制などがあります。
# Example: List organization policies for a project
gcloud org-policies list --project=your-project-id
# Example: Describe a specific organization policy
gcloud org-policies describe compute.disableExternalIpAccess --organization=your-organization-id
Googleの内部クラスタ管理システムであるBorgは、Kubernetesの直接の祖先です。この系譜を理解することで、GCPのコンテナファーストの哲学と、その多くのサービスの設計原則についての洞察が得られます。
| コンセプト | Borgの影響 | GCPでの具現化 |
|---|---|---|
| コンテナ化 | Borgは、コンテナベースのワークロード分離とスケジューリングを大規模に開拓しました。 | Docker、Container Registry、Cloud Run、GKE。 |
| 宣言型API | Borgは、宣言型仕様を介してワークロードを管理しました。 | Kubernetes YAML、Cloud Deployment Manager、Terraform。 |
| 自己修復システム | Borgは、失敗したタスクを自動的に再スケジュールし、望ましい状態を維持しました。 | GKE Autopilot、マネージドインスタンスグループ、Cloud Runのオートスケーリング。 |
| サービスディスカバリ | Borgは内部サービスディスカバリメカニズムを提供しました。 | Cloud DNS、内部ロードバランサー、GKEサービスディスカバリ。 |
| リソース効率 | Borgの主な目標は、クラスタ利用率を最大化することでした。 | GKE Autopilotのノード管理、サーバーレスサービス(Cloud Run、Cloud Functions)。 |
実用的な教訓: Google Cloudは、コンテナ化されたイミュータブルなインフラストラクチャ向けに本質的に設計されています。このパラダイムを受け入れてください。Cloud RunやGKE Autopilotのようなサービスは、単に便利であるだけでなく、Googleの数十年にわたる内部運用経験の集大成を表しています。
このアーキテクチャは、ゼロトラスト原則と多層防御を重視した、Google Cloud上での堅牢で安全かつスケーラブルなエンタープライズデプロイメントを示しています。
ゼロトラストデータフローと多層防御:
このアーキテクチャは、ネットワーク境界内であっても暗黙の信頼を仮定しないことで、ゼロトラストを具現化しています。すべてのインタラクションには明示的な承認が必要であり、すべてのレイヤーが潜在的な脅威に対する防御を提供します。
このドメインでは、Google Cloudの主要なコンピューティングサービスについて説明します。これには、完全に管理されたサーバーレスプラットフォームから、高度にカスタマイズ可能な仮想マシンやコンテナオーケストレーションまでが含まれます。実用的な適用、トレードオフの理解、およびプロダクショングレードのワークロードのための高度な機能の活用に焦点を当てています。
Cloud Runは、コンテナ化されたアプリケーションをデプロイするための完全に管理されたコンピューティングプラットフォームです。インフラストラクチャ管理を抽象化し、開発者がコードに集中できるようにします。
min-instancesを設定して、指定された数のインスタンスをウォーム状態に保ち、トラフィックを処理できるようにすることができます。これにより、これらのインスタンスに対して継続的な課金が発生します。--cpuおよび--gpuフラグを介して構成されます。GKEはGoogle CloudのマネージドKubernetesサービスであり、コンテナ化されたアプリケーションのデプロイ、管理、スケーリングのための堅牢なプラットフォームを提供します。
Autopilot vs Standard: | 機能 | GKE Standard | GKE Autopilot | | :------ | :----------- | :------------ | | ノード管理 | ユーザー管理 | Google管理 | | 料金 | VM + GKE料金 | Podベース | | カスタマイズ | 高い(ノードプール、OS) | 制限あり(事前定義プロファイル) | | セキュリティ | 共有責任 | 強化(強化されたノード) | | スケーリング | 手動/CA | 自動(Pod駆動) | | ユースケース | 最大限の制御、カスタムOS | ハンズオフ、コスト最適化 |
マルチクラスタイングレス: 単一のグローバル外部IPアドレスを使用して、複数のGKEクラスタ(異なるリージョンにある可能性もある)にデプロイされたアプリケーションにトラフィックをルーティングできます。これにより、地理的に分散されたサービスに対して、グローバルロードバランシング、フェイルオーバー、および簡素化されたDNS管理が提供されます。
Gateway API: Kubernetesイングレスの次世代APIであり、従来のIngress APIと比較して、ルーティング、トラフィック管理、ポリシー適用を構成するためのより表現力豊かで拡張可能な方法を提供します。GatewayClass、Gateway、HTTPRoute、TCPRouteなどの概念を導入しています。
Compute Engineは、さまざまなマシンタイプ、ストレージオプション、および料金モデルを備えた高度にカスタマイズ可能な仮想マシン(VM)を提供します。
Cloud Functions 第2世代はCloud Run上に構築されており、その基盤となるインフラストラクチャと機能を継承しています。
Cloud Batchは、高スループットのバッチコンピューティングのための完全に管理されたサービスです。大規模な並列およびシーケンシャルバッチジョブの実行を簡素化します。
| サービス | 主要なアーキタイプ | 最適な場合 | 避けるべき場合 |
|---|---|---|---|
| Cloud Run | サーバーレスコンテナ | HTTP/イベント駆動型マイクロサービス、API | 長時間実行されるステートフルなアプリ、極端なGPU要件 |
| GKE | コンテナオーケストレーション | 複雑なマイクロサービス、カスタム制御、ハイブリッド | シンプルなアプリ、最小限の運用チーム |
| Compute Engine | IaaS VM | レガシーアプリ、カスタムOS、特定のハードウェア | サーバーレスが理想的、高い運用オーバーヘッド |
| Cloud Functions | サーバーレスFaaS | イベント駆動型、短命、ステートレス関数 | 長時間実行されるプロセス、複雑な状態 |
| Cloud Batch | バッチ処理 | HPC、大規模データ処理、アレイジョブ | リアルタイム、インタラクティブ、低遅延 |
gcloud CLIレシピ# Deploy a Cloud Run service with specific resource limits, min/max instances, and VPC egress
gcloud run deploy my-service \
--image gcr.io/my-project/my-app:v1.0.0 \
--platform managed \
--region us-central1 \
--project my-project-id \
--service-account my-service-account@my-project-id.iam.gserviceaccount.com \
--cpu 2 \
--memory 2Gi \
--min-instances 1 \
--max-instances 10 \
--concurrency 80 \
--timeout 300s \
--vpc-egress all \
--vpc-connector projects/my-project-id/locations/us-central1/connectors/my-vpc-connector \
--set-env-vars ENV_VAR_KEY=ENV_VAR_VALUE \
--no-allow-unauthenticated
# Create a Cloud Run Job for a batch task
gcloud run jobs create my-batch-job \
--image gcr.io/my-project/my-batch-processor:v1.0.0 \
--region us-central1 \
--project my-project-id \
--service-account my-batch-sa@my-project-id.iam.gserviceaccount.com \
--cpu 4 \
--memory 8Gi \
--tasks 10 \
--parallelism 5 \
--timeout 3600s \
--set-env-vars INPUT_BUCKET=gs://my-input-data,OUTPUT_BUCKET=gs://my-output-data
# Create a GKE Autopilot cluster with release channel and private endpoint
gcloud container clusters create-auto my-autopilot-cluster \
--region us-central1 \
--project my-project-id \
--release-channel stable \
--network projects/my-project-id/global/networks/my-vpc \
--subnetwork projects/my-project-id/regions/us-central1/subnetworks/my-gke-subnet \
--enable-private-nodes \
--enable-private-endpoint \
--master-ipv4-cidr 172.16.0.0/28 \
--workload-pool my-project-id.svc.id.goog \
--enable-workload-identity
# Create a Compute Engine Spot VM with Hyperdisk Balanced and a specific service account
gcloud compute instances create my-spot-vm \
--project my-project-id \
--zone us-central1-a \
--machine-type n2-standard-4 \
--provisioning-model SPOT \
--instance-termination-action STOP \
--boot-disk-device-name my-spot-boot-disk \
--boot-disk-type hyperdisk-balanced \
--boot-disk-size 50GB \
--image-family debian-11 \
--image-project debian-cloud \
--network-interface network=my-vpc,subnet=my-compute-subnet \
--service-account my-compute-sa@my-project-id.iam.gserviceaccount.com \
--scopes=https://www.googleapis.com/auth/cloud-platform \
--metadata startup-script='#!/bin/bash\necho "Hello from Spot VM" > /tmp/startup.txt'
# Deploy a 2nd Gen Cloud Function triggered by a Pub/Sub topic
gcloud functions deploy my-pubsub-function-v2 \
--gen2 \
--runtime python39 \
--region us-central1 \
--project my-project-id \
--source ./function-source \
--entry-point process_message \
--trigger-topic my-pubsub-topic \
--service-account my-function-sa@my-project-id.iam.gserviceaccount.com \
--memory 512MB \
--timeout 300s \
--concurrency 10 \
--vpc-connector projects/my-project-id/locations/us-central1/connectors/my-vpc-connector \
--egress-settings private-ranges-only
# Submit a Cloud Batch job using a JSON configuration file
# job_config.json example:
# {
# "taskGroups": [
# {
# "taskSpec": {
# "runnables": [
# {
# "script": {
# "text": "echo 'Processing task ${BATCH_TASK_INDEX}' && sleep 10"
# }
# }
# ],
# "computeResource": {
# "cpuMilli": 1000,
# "memoryMib": 512
# }
# },
# "taskCount": 5,
# "parallelism": 2
# }
# ],
# "allocationPolicy": {
# "instances": [
# {
# "policy": {
# "machineType": "e2-standard-2",
# "provisioningModel": "SPOT"
# }
# }
# ]
# },
# "logsPolicy": {
# "destination": "CLOUD_LOGGING"
# }
# }
gcloud batch jobs submit my-batch-job-from-file \
--location us-central1 \
--project my-project-id \
--config job_config.json \
--service-account my-batch-sa@my-project-id.iam.gserviceaccount.com
Cloud SQL は、PostgreSQL、MySQL、SQL Server 向けのフルマネージド型リレーショナルデータベースサービスである。パッチ適用、バックアップ、レプリケーションなどの運用上のオーバーヘッドを抽象化し、アプリケーション開発への集中を可能にする。
Cloud SQL はこれらの主要なデータベースエンジンの最新メジャーバージョンをサポートしており、既存のアプリケーションやツールとの互換性を提供する。
Cloud SQL HA は、同一リージョン内の異なるアベイラビリティゾーンにあるスタンバイインスタンスへの自動フェイルオーバーにより、ビジネス継続性を確保する。これは、プライマリインスタンスからスタンバイへデータを同期レプリケーションすることで実現される。プライマリインスタンスの障害(ゾーン障害やインスタンスのクラッシュなど)が発生した場合、Cloud SQL は自動的にスタンバイをプライマリへ昇格させ、ダウンタイムを最小限に抑える。
Cloud SQL は、OS のパッチ適用、データベースエンジンのアップデート、セキュリティ脆弱性の修正といった定常的なメンテナンスタスクを自動で処理する。本番ワークロードへの影響を最小限に抑えるため、希望する曜日と時間帯を指定してメンテナンスウィンドウを構成できる。
リードレプリカは、読み取り集中型のワークロードをプライマリインスタンスからオフロードし、パフォーマンスとスケーラビリティを向上させる。プライマリインスタンスの非同期コピーであり、レポート作成、分析、地理的に分散した読み取りアクセスに適している。
どちらのメカニズムも、パブリックインターネットへの露出を避けつつ Cloud SQL インスタンスへのプライベート接続を可能にする。
プライベート IP ピアリング(VPC ネットワークピアリング):
Private Service Connect(PSC):
AlloyDB は、要求の厳しいエンタープライズワークロード向けに設計されたフルマネージドの PostgreSQL 互換データベースサービスであり、標準の PostgreSQL と比較して優れたパフォーマンスと可用性を提供する。
AlloyDB は、コンピューティング(クエリ処理)とストレージ(データ永続化)を分離している。
AlloyDB は分析クエリ用のカラムナエンジンを組み込んでいる。標準の PostgreSQL は主に行指向(ロー指向)であるが、AlloyDB のインテリジェントなストレージレイヤーは特定のテーブルやパーティションのデータをカラムナ形式で保持できる。これにより、個別の ETL プロセスやデータウェアハウスを必要とせず、分析ワークロード(OLAP クエリなど)を大幅に高速化する。このハイブリッドトランザクション/分析処理(HTAP)機能は大きな差別化要因である。
AlloyDB は pgvector 拡張機能をサポートしており、データベース内で直接ベクトル埋め込みを効率的に保存およびクエリできる。これは、類似性検索、レコメンデーションエンジン、セマンティック検索などの AI/ML アプリケーションにおいて極めて重要である。
Cloud Spanner は、高い可用性と大規模なスケーラビリティを必要とするミッションクリティカルなアプリケーション向けに構築された、グローバル分散型の強整合性リレーショナルデータベースサービスである。
TrueTime は Spanner の基盤技術であり、不確実性の範囲が厳密に制限されたグローバルに一貫したウォールクロック時刻を提供する。
[earliest, latest] を提供し、時刻 t より前にコミットされたすべてのトランザクションが時刻 t までにどこからでも参照可能であることを保証する。これにより外部整合性が実現される。Spanner は、直列化可能性(Serializability)よりも強力な保証である外部整合性(External Consistency)を提供する。これは、どのクライアントから観測されたトランザクションのグローバルな順序も、現実世界のウォールクロック(実時間)におけるトランザクションの順序と一致することを意味する。これにより分散トランザクションの設計が簡素化され、大陸をまたいだデータ整合性が確保される。
nam-eur-asia1 など)間でデータが同期レプリケーションされる。極めて高い可用性(99.999% の SLA)と、グローバルに分散したアプリケーション向けの低レイテンシな読み取りを提供する。整合性を保つため、書き込みは引き続きプライマリリージョンにルーティングされる。Spanner インスタンスは「処理ユニット(PU)」単位でサイジングされる。各 PU は一定量の CPU、メモリ、I/O 容量を提供する。
Spanner Graph は、Spanner の強整合性とスケーラビリティを活用しながら、Spanner データに対してグラフのようなクエリを直接実行できる機能である。独立したグラフデータベースではなく、Spanner 内でグラフデータをモデリングおよびクエリするための機能群とベストプラクティスのセットである。
Firestore は、モバイル、Web、サーバー開発向けの柔軟でスケーラブルな NoSQL ドキュメントデータベースである。リアルタイム同期とオフラインサポートを提供する。
Firestore には 2 つのモードがあり、主に API と機能セットが異なる。
ネイティブモード(Firestore):
Datastore モード(Cloud Datastore):
Firestore のリアルタイムリスナーを使用すると、クライアントはドキュメントまたはクエリ結果セットの変更をサブスクライブできる。サーバー上でデータが変更されると、Firestore は接続されているクライアントにリアルタイムで更新をプッシュする。
Firestore はすべてのフィールドに対して単一フィールドインデックスを自動的に作成する。ただし、複数のフィールドを含むクエリ(例: WHERE field1 == 'value' AND field2 > 'value')には複合インデックスが必要となる。
firebase.indexes.json ファイルを介して手動で定義する。単一ドキュメント内のカウンターフィールドを直接インクリメントすると、高い同時実行性のシナリオで競合やパフォーマンスのボトルネックが発生する可能性がある。Firestore はこれを緩和するための分散カウンターパターンをサポートしている。
FieldValue.increment() を使用して、現在の値を最初に読み取ることなく数値フィールドをアトミックに更新し、読み取り・変更・書き込みの競合を減らす。Cloud Bigtable は、大規模な分析および運用ワークロード向けに設計されたフルマネージドのペタバイト規模 NoSQL データベースサービスである。時系列データ、マーケティングデータ、金融データ、IoT データに最適である。
Bigtable はログ構造化マージツリー(LSM-tree)アーキテクチャに基づいて構築されている。
データは行キーによって辞書順に保存されるため、行キーの設計は Bigtable のパフォーマンスにとって極めて重要である。
timestamp#device_id)と、最新データへのアクセスが集中してホットスポットが発生する。device_id#reverse_timestamp)やハッシュプレフィックス(例: hash(device_id)#timestamp)を使用して均等に分散させる。user_id#order_id)。Bigtable は 2 種類のストレージタイプを提供している。
Bigtable はマルチクラスターレプリケーションをサポートしており、異なるリージョンやゾーンにある複数のクラスター間でデータをレプリケーションできる。
Bigtable は BigQuery とスムーズに統合でき、高度な分析を実行できる。
Memorystore は Redis および Memcached 向けのフルマネージドサービスであり、高いスケーラビリティと可用性を備えたインメモリデータストアを提供する。
Memorystore for Redis には Basic と Standard の 2 つの階層がある。Standard 階層は高可用性とレプリケーションをサポートしている。Memorystore for Redis Cluster は、シャーディングされた Redis デプロイメント向けの専用オファリングである。
Valkey は、Redis からフォークされたオープンソースの高性能インメモリデータストアである。Memorystore for Valkey は、Valkey インスタンス向けのマネージドサービスを提供する。
Memorystore for Redis(Standard 階層および Cluster)は、再起動や障害時のデータ損失を防ぐための永続化オプションを提供している。
Memorystore for Redis Cluster では、クラスターサイズを動的にスケーリングできる。
| データベースサービス | エンジンとモデル | スループット / スケール | 整合性モデル | 最適なユースケース |
|---|---|---|---|---|
| Cloud SQL | PostgreSQL、MySQL、SQL Server(リレーショナル) | GB/秒、TB 規模、垂直スケール | 強整合性 | OLTP、Web アプリ、エンタープライズアプリ |
| AlloyDB | PostgreSQL(リレーショナル、HTAP) | TB/秒、PB 規模、水平スケール | 強整合性 | 高性能 OLTP、HTAP、AI/ML |
| Cloud Spanner | カスタム(グローバル分散リレーショナル) | TB/秒、PB 規模、グローバル水平スケール | 外部整合性 | ミッションクリティカル、グローバル OLTP |
| Firestore | NoSQL ドキュメント | MB/秒、PB 規模、水平スケール | 強整合性(ネイティブ)、結果整合性(Datastore) | モバイル/Web アプリ、リアルタイム、IoT |
| Cloud Bigtable | NoSQL ワイドカラム | GB/秒、PB 規模、水平スケール | 結果整合性 | 時系列、IoT、アドテク、分析 |
| Memorystore | Redis、Valkey、Memcached(インメモリ KV) | GB/秒、TB 規模、水平スケール | 結果整合性 | キャッシュ、セッション管理、リアルタイム分析 |
gcloud CLI レシピこのコマンドは、高可用性、プライベート IP 接続、自動バックアップ、および特定のメンテナンスウィンドウを備えた Cloud SQL PostgreSQL インスタンスをプロビジョニングする。
gcloud sql instances create my-prod-pg-instance \
--database-version=POSTGRES_14 \
--region=us-central1 \
--cpu=4 \
--memory=16GB \
--storage-size=500GB \
--storage-type=SSD \
--availability-type=REGIONAL \
--enable-bin-log \
--backup-start-time="03:00" \
--backup-location=us-central1 \
--database-flags="log_statement=all,max_connections=500" \
--maintenance-window-day=SATURDAY \
--maintenance-window-hour=02 \
--network=projects/my-gcp-project/global/networks/my-vpc-network \
--no-assign-ip \
--allocated-ip-range-name=my-cloudsql-private-range \
--root-password="<YOUR_STRONG_PASSWORD>" \
--project=my-gcp-project
--database-version: PostgreSQL のバージョンを指定する。--region: インスタンスを us-central1 にデプロイする。--cpu、--memory、--storage-size、--storage-type: インスタンスのリソースを定義する。--availability-type=REGIONAL: リージョンフェイルオーバーを伴う高可用性(HA)を有効にする。--enable-bin-log: ポイントインタイムリカバリおよびレプリケーションに不可欠なバイナリログを有効にする。--backup-start-time、--backup-location: 自動日次バックアップを構成する。--database-flags: PostgreSQL 固有のフラグを設定する。--maintenance-window-day、--maintenance-window-hour: 希望するメンテナンスウィンドウを定義する。--network: プライベート IP 用に指定された VPC ネットワークに接続する。--no-assign-ip: インスタンスがプライベート IP 経由でのみアクセス可能であることを保証する。--allocated-ip-range-name: プライベートサービスアクセス用に割り当てられた名前付き IP 範囲を指定する。この範囲は事前に VPC 内で割り当てておく必要がある。--root-password: 初期の root ユーザーパスワードを設定する。--project: Google Cloud プロジェクト ID を指定する。このコマンドは、高可用性とプライベート IP を構成した AlloyDB クラスターとその中のプライマリインスタンスを作成する。
# Create an AlloyDB cluster
gcloud alloydb clusters create my-prod-alloydb-cluster \
--database-version=POSTGRES_14 \
--region=us-central1 \
--network=projects/my-gcp-project/global/networks/my-vpc-network \
--allocated-ip-range-name=my-alloydb-private-range \
--project=my-gcp-project
# Create a primary instance within the cluster
gcloud alloydb instances create my-prod-alloydb-primary \
--cluster=my-prod-alloydb-cluster \
--instance-type=PRIMARY \
--cpu-count=4 \
--region=us-central1 \
--project=my-gcp-project
alloydb clusters create: クラスターリソースを作成する。--database-version: AlloyDB 用の PostgreSQL バージョンを指定する。--network、--allocated-ip-range-name: プライベート IP 接続を構成する。alloydb instances create: 指定されたクラスター内にインスタンスを作成する。--instance-type=PRIMARY: これをプライマリインスタンスとして指定する。--cpu-count: プライマリインスタンスの vCPU 数を指定する。ストレージは AlloyDB によって自動的に管理される。このコマンドは、指定された数の処理ユニット(PU)を持つマルチリージョンの Cloud Spanner インスタンスを作成する。
gcloud spanner instances create my-prod-spanner-global \
--config=nam-eur-asia1 \
--description="Production Global Spanner Instance" \
--processing-units=1000 \
--project=my-gcp-project
--config=nam-eur-asia1: 北米、ヨーロッパ、アジアにまたがるマルチリージョン構成を指定する。regional-us-central1 などの他の構成はリージョンインスタンス用である。--processing-units=1000: インスタンスに 1000 処理ユニット(1 ノードに相当)を割り当てる。この値を増やすことでスケールアップできる。このコマンドは、SSD ストレージを備えた Bigtable インスタンスと、レプリケーション用に異なるリージョンに配置されたクラスターを作成する。
# Create the primary Bigtable instance and cluster
gcloud bigtable instances create my-prod-bigtable \
--display-name="Production Bigtable Instance" \
--cluster-id=my-prod-bigtable-c1 \
--cluster-zone=us-central1-f \
--cluster-num-nodes=3 \
--cluster-storage-type=SSD \
--project=my-gcp-project
# Add a replica cluster in a different region/zone
gcloud bigtable clusters create my-prod-bigtable-c2 \
--instance=my-prod-bigtable \
--cluster-zone=europe-west1-b \
--cluster-num-nodes=3 \
--cluster-storage-type=SSD \
--project=my-gcp-project
bigtable instances create: Bigtable インスタンスとその初期クラスターを作成する。--cluster-id、--cluster-zone、--cluster-num-nodes、--cluster-storage-type: プライマリクラスターのプロパティを定義する。bigtable clusters create: レプリケーション用に既存のインスタンスへ新しいクラスターを追加する。--instance: クラスターを追加する既存のインスタンスを指定する。--cluster-zone: レプリカクラスターを異なるゾーン/リージョンに配置する。このコマンドは、指定されたシャード数とノード構成を持つ Memorystore for Redis Cluster を作成する。
gcloud memorystore redis clusters create my-prod-redis-cluster \
--region=us-central1 \
--shard-count=6 \
--node-count-per-shard=2 \
--node-cpu-count=2 \
--node-memory-gb=4 \
--network=projects/my-gcp-project/global/networks/my-vpc-network \
--transit-encryption-mode=SERVER_AUTHENTICATION \
--project=my-gcp-project
memorystore redis clusters create: Redis Cluster インスタンスを作成する。--shard-count: クラスター内のシャード数を定義する。--node-count-per-shard: シャードあたりのノード数(プライマリ + レプリカ)を指定する。2 は、HA のためにシャードあたり 1 つのプライマリと 1 つのレプリカを配置することを意味する。--node-cpu-count、--node-memory-gb: 各ノードのリソースを構成する。--network: 指定された VPC ネットワークに接続する。--transit-encryption-mode=SERVER_AUTHENTICATION: 転送中の暗号化を有効にする。--project: Google Cloud プロジェクト ID を指定する。本ドメインは、多様なアクセスパターン、パフォーマンス要件、コストプロファイルにわたるデータ管理に不可欠な、Google Cloudが提供するコアストレージサービスを網羅する。オブジェクトストレージ、ブロックストレージ、ファイルストレージの各ソリューション、およびコンテンツ配信ネットワーク(CDN)について解説する。
Google Cloud Storage (GCS) は、高い耐久性と可用性を備えたオブジェクトストレージサービスである。多様なストレージクラス、オブジェクトのライフサイクル管理、およびデータ保護とパフォーマンスのための高度な機能を提供する。
GCSは、異なるアクセス頻度とコスト要件に最適化された4つの主要なストレージクラスを提供する。マルチリージョンまたはリージョンに保存されたオブジェクトに対して、すべてのクラスで同一の低レイテンシ(Time to First Byte:ミリ秒単位)を提供する。
| クラス | アクセス頻度 | 最小ストレージ期間 | 取得コスト | ユースケース |
|---|---|---|---|---|
| Standard | 高頻度 | なし | なし | アクティブデータ、Webコンテンツ、分析 |
| Nearline | 月に1回未満 | 30日 | 低 | バックアップ、ディザスタリカバリ、アクセス頻度の低いデータ |
| Coldline | 四半期に1回未満 | 90日 | 中 | アーカイブ、長期バックアップ、コンプライアンスデータ |
| Archive | 年に1回未満 | 365日 | 高 | ディープアーカイブ、規制コンプライアンス、コールドデータ |
主な考慮事項:
Autoclassは、アクセスパターンに基づいてストレージクラス間でオブジェクトを自動的に移行し、手動介入なしでコストを最適化する。オブジェクトのアクセス状況を30日間監視し、最も費用対効果の高いクラスに移動する。オブジェクトは、アクセスされた場合はStandardに、そうでない場合はNearline、Coldline、そして最終的にArchiveへと移行される。
Autoclassの有効化:
gcloud storage buckets update gs://your-bucket-name --autoclass-enable
オブジェクトのライフサイクル管理 (OLM) を使用すると、経過日数、作成日、バージョン数などの条件に基づいて、ストレージクラス間のオブジェクトの自動移行、オブジェクトの削除、または古いバージョンのオブジェクトの削除を行うルールを定義できる。ポリシーはJSON配列として定義する。
OLMポリシーの例 (JSON):
{
"lifecycle": {
"rule": [
{
"action": {"type": "SetStorageClass", "storageClass": "NEARLINE"},
"condition": {"age": 30}
},
{
"action": {"type": "Delete"},
"condition": {"age": 365, "isLive": true}
},
{
"action": {"type": "Delete"},
"condition": {"numNewerVersions": 3}
}
]
}
}
このポリシーは、30日経過後にオブジェクトをNearlineに移行し、365日経過後にライブオブジェクトを削除し、より新しいバージョンが3つある場合は古いバージョンを削除する。
OLMポリシーの適用:
gcloud storage buckets update gs://your-bucket-name --lifecycle-file=lifecycle-policy.json
ソフトデリートは、削除されたオブジェクトを復元できる設定可能な保持期間(1〜90日)を提供する。これは、誤削除に対するセーフティネットとして機能する。ソフトデリートの期間中、オブジェクトにはアクセスできないが復元は可能である。期間経過後は完全に削除される。
ソフトデリートの有効化:
gcloud storage buckets update gs://your-bucket-name --soft-delete-duration=7d # 7 days retention
ターボレプリケーションは、新しく書き込まれたオブジェクトをデュアルリージョンまたはマルチリージョンのバケットにほぼリアルタイムでレプリケーションする。これは、通常15分以内という、リージョンをまたぐデータ冗長性のための極めて低い目標復旧時点 (RPO) を必要とするユースケースに不可欠である。特定のコンプライアンスや事業継続性の要件に対応するためのアドオン機能である。
ターボレプリケーションの有効化 (デュアルリージョンの例):
# Turbo Replication is configured at bucket creation or update.
# It requires the bucket to be dual-region or multi-region.
# Example: Create a dual-region bucket with Turbo Replication enabled
gcloud storage buckets create gs://your-turbo-bucket --location=nam4 --enable-turbo-replication
均一なバケットレベルのアクセス (UBLA) は、バケット内のすべてのオブジェクトがバケットのIAMポリシーを継承することを強制することでアクセス制御を簡素化する。これによりオブジェクトACLが無効化され、一貫性のある監査可能な権限モデルが保証される。きめ細かく、競合する可能性のあるオブジェクトレベルのACLを防ぐための、多くのエンタープライズデプロイメントにおけるベストプラクティスである。
UBLAの有効化:
gcloud storage buckets update gs://your-bucket-name --uniform-bucket-level-access
Google Cloudは、Compute Engineインスタンス向けのブロックストレージソリューションを提供し、耐久性とパフォーマンスに優れたストレージを実現する。
Persistent Diskは、ネットワークアタッチト型のブロックストレージデバイスである。VMインスタンスから分離されているため、デタッチして他のインスタンスに再アタッチすることが可能である。
リージョンPersistent Disk: リージョン内の2つのゾーン間でデータの同期レプリケーションを提供する。これにより、ゾーン障害が発生した場合にCompute Engineインスタンスを別のゾーンへ自動フェイルオーバーでき、クリティカルなアプリケーションのRTOが大幅に改善される。
Hyperdiskは、極めて高いパフォーマンスとスケーラビリティを実現するために設計された次世代のブロックストレージサービスである。ディスクサイズからIOPSとスループットを分離し、独立したスケーリングを可能にする。
スナップショットスケジュールは、Persistent Diskのスナップショット作成を自動化し、ディザスタリカバリやデータ保護のためのポイントインタイムバックアップを提供する。スナップショットは増分バックアップであり、変更されたブロックのみを保存するため、ストレージコストを削減できる。
スナップショットスケジュールの作成:
gcloud compute resource-policies create snapshot-schedule my-daily-snapshot-schedule \
--region=us-central1 \
--start-time=03:00 \
--daily-schedule \
--max-retention-days=7 \
--storage-location=us-central1
ディスクへのスナップショットスケジュールの適用:
gcloud compute disks add-resource-policies my-disk-name \
--resource-policies=my-daily-snapshot-schedule \
--zone=us-central1-a
Filestoreは、共有ファイルシステムインターフェース (NFS) を必要とするアプリケーション向けの、フルマネージドの高性能ファイルストレージサービスである。
| 機能 | Basicティア | Enterpriseティア |
|---|---|---|
| ユースケース | GKE、基本的なファイル共有、開発/テスト | ミッションクリティカルなアプリ、GKE、SAP、データベース |
| プロトコル | NFSv3 | NFSv3, NFSv4.1 |
| 可用性 | ゾーン | リージョン (マルチゾーン) |
| 耐久性 | ゾーン | リージョン (マルチゾーン) |
| パフォーマンス | Standard、Premium、High Scale | High Scale |
| スナップショット | あり | あり |
| レプリケーション | なし | あり (リージョン) |
| 最大容量 | 256 TB | 100 TB (インスタンスあたり) |
GKE向けの大規模なNFS (High-Scale NFS): Filestore Enterpriseは、永続的で共有可能なストレージを必要とするGKEワークロードに特に適している。そのリージョンレベルの可用性と高性能な特性により、GKEクラスター内の複数のゾーンにまたがってデプロイされるステートフルアプリケーションに対して、データの耐久性と低レイテンシのアクセスが保証される。
Filestore Enterpriseインスタンスの作成:
gcloud filestore instances create my-enterprise-filestore \
--zone=us-central1-a \
--tier=ENTERPRISE \
--file-share=name=my-share,capacity=1TB \
--network=name=default \
--description="Enterprise Filestore for GKE"
コンテンツ配信ネットワーク (CDN) は、ユーザーに近い場所でコンテンツをキャッシュし、レイテンシとオリジンサーバーの負荷を軽減することで、Webコンテンツとメディアを効率的に配信するために不可欠である。
Cloud CDNはHTTP(S) 負荷分散と連携し、Googleのグローバルエッジネットワークでコンテンツをキャッシュする。
Cache-Control HTTPヘッダー(max-age、s-maxage、no-cache、no-storeなど)を使用する。image.jpg?v=12345)、明示的な無効化を行わずに新しいコンテンツが確実に取得されるようにする。gcloud compute url-maps invalidate-cdn-cacheを使用して特定のURLまたはプレフィックスを明示的に無効化する。これにはコストがかかり、オリジンに負荷がかかる可能性があるため、慎重に使用する必要がある。Cloud CDNキャッシュの無効化:
gcloud compute url-maps invalidate-cdn-cache my-url-map \
--path="/images/*" # Invalidate all objects under /images/
Media CDNは、大規模な動画ストリーミングとメディア配信に最適化された特化型CDNである。Cloud CDNと比較して、より高いスループット、より低いレイテンシ、およびメディアワークロード向けに調整された高度な機能を提供する。
| ストレージサービス | プロトコル / インターフェース | スループットとレイテンシ | 耐久性 SLA | コストプロファイル |
|---|---|---|---|---|
| Cloud Storage | HTTP(S) REST API | ミリ秒 (TTFB) | 99.999999999% | クラス、オペレーション、下り(外向き)通信による階層別 |
| Persistent Disk | ブロック (SCSI/NVMe) | タイプにより異なる (MB/s, IOPS) | 99.999% | GB単価、プロビジョニングされたIOPS/スループット |
| Hyperdisk | ブロック (SCSI/NVMe) | 高 (最大100万IOPS, 4.8 GB/s) | 99.999% | GB単価、プロビジョニングされたIOPS/スループット |
| Filestore | NFSv3, NFSv4.1 | 高 (MB/s, IOPS) | 99.9% (Basic), 99.99% (Enterprise) | GB単価、パフォーマンスティア別 |
| Cloud CDN | HTTP(S) | 低レイテンシ (エッジキャッシュ) | 該当なし (キャッシュサービス) | 下り通信、キャッシュフィル、キャッシュ無効化 |
| Media CDN | HTTP(S) | 非常に低いレイテンシ (メディア最適化) | 該当なし (キャッシュサービス) | 下り通信、キャッシュフィル、高度な機能 |
gcloud CLI レシピこのレシピでは、セキュリティ、データ保持、コスト最適化のベストプラクティスを適用したGCSバケットの作成手順を示す。
ライフサイクルポリシーの定義 (lifecycle-policy.json): このポリシーは、30日後にオブジェクトをNearlineに移行し、365日後に削除する。また、7日経過した非現行バージョンのオブジェクトも削除する。
{
"lifecycle": {
"rule": [
{
"action": {"type": "SetStorageClass", "storageClass": "NEARLINE"},
"condition": {"age": 30, "isLive": true}
},
{
"action": {"type": "Delete"},
"condition": {"age": 365, "isLive": true}
},
{
"action": {"type": "Delete"},
"condition": {"numNewerVersions": 1, "isLive": false, "age": 7}
}
]
}
}
均一なバケットレベルのアクセス、バージョニング、ソフトデリートを有効にしたバケットの作成:
--uniform-bucket-level-access: IAMのみの権限を強制する。--retention-period=365d: デフォルトのオブジェクト保持期間を365日に設定する。この期間が経過するまで、オブジェクトの削除や上書きはできない。--enable-soft-delete: バケットのソフトデリートを有効にする。--soft-delete-duration=7d: ソフトデリートの保持期間を7日に設定する。--versioning: 偶発的な上書きから保護するために、オブジェクトのバージョニングを有効にする。--default-storage-class=STANDARD: 新しいオブジェクトのデフォルトストレージクラスを設定する。--location=US-CENTRAL1: リージョンのロケーションを指定する。gcloud storage buckets create gs://your-production-data-bucket-001 \
--uniform-bucket-level-access \
--retention-period=365d \
--enable-soft-delete \
--soft-delete-duration=7d \
--versioning \
--default-storage-class=STANDARD \
--location=US-CENTRAL1 \
--project=your-gcp-project-id
ライフサイクルポリシーの適用:
gcloud storage buckets update gs://your-production-data-bucket-001 \
--lifecycle-file=lifecycle-policy.json \
--project=your-gcp-project-id
バケット設定の確認:
gcloud storage buckets describe gs://your-production-data-bucket-001 \
--project=your-gcp-project-id
設定が反映されていることを確認するには、出力から uniformBucketLevelAccess、retentionPolicy、softDeletePolicy、versioning、defaultEventBasedHold、および lifecycle の項目を確認する。
Google Cloud におけるエンタープライズネットワーキングには、堅牢で安全かつスケーラブルなアーキテクチャが求められる。本セクションでは、セキュリティとハイブリッド接続に重点を置きながら、主要コンポーネント、その相互依存関係、および本番環境でのデプロイにおけるベストプラクティスを詳述する。
VPC は Google Cloud におけるネットワーキングの基盤であり、リソースに対して論理的に分離されたネットワークを提供する。
カスタムモードの VPC ネットワークは、IP アドレス範囲をきめ細かく制御できるため、正確なセグメンテーションと IP アドレス空間の管理が可能である。これは、既存の IP アドレス体系を持つ大企業や、厳格なコンプライアンス要件を満たす必要がある環境において極めて重要である。
10.0.0.0/8、172.16.0.0/12、192.168.0.0/16)を使用する。PGA を有効にすると、内部 IP アドレスのみを持つ VM がインターネットを経由せずに Google API やサービス(Cloud Storage、BigQuery など)へ到達できる。これにより、セキュリティが向上し、下り(外向き)通信のコストを削減できる。
private.googleapis.com または restricted.googleapis.com エンドポイントを使用するサービスの場合、DNS 名前解決の構成(Cloud DNS 限定公開ゾーンやオンプレミス DNS フォワーディングなど)が必要である。共有 VPC(XPN)を使用すると、組織内の複数のプロジェクトを共通のホストプロジェクトの VPC ネットワークに接続できる。これにより、ネットワーク管理が一元化され、接続性が簡素化されるとともに、一貫したネットワークポリシーの適用が可能となる。
VPC ネットワーク ピアリングは 2 つの VPC ネットワークを接続し、各ネットワーク内のリソースが内部 IP アドレスを使用して通信できるようにする機能である。強力である一方、以下のような制限が存在する。
Cloud NAT を使用すると、外部 IP アドレスを持たないインスタンスからインターネットへのアウトバウンド接続を開始できる。マネージドサービスであるため、手動で NAT ゲートウェイを構成・管理する必要がない。
Cloud NAT はトラフィックに応じて自動的にスケーリングするが、NAT IP アドレスの最小数と VM あたりの最小ポート割り当て数は事前に構成する。
nat_allocatable_ports_utilization および nat_active_connections メトリクスをモニタリングし、ポート割り当てを最適化する。Cloud NAT は送信元ネットワークアドレス変換(SNAT)およびポートアドレス変換(PAT)を使用する。VM からの各アウトバウンド接続は、NAT ゲートウェイ上の送信元ポートを消費する。
PSC を利用すると、VPC ピアリングの制限を回避して VPC ネットワーク間でサービスをプライベートに利用できるため、ネットワークアーキテクチャを大幅に簡素化できる。
PSC は、特にサービス利用のユースケースにおいて VPC ピアリングの代替として機能する。N 個の VPC を中央のサービス VPC とピアリングする代わりに、各コンシューマー VPC がサービスプロデューサーのサービスアタッチメントに対して PSC エンドポイントを確立できるため、25 個のピアリング上限や推移的ルーティングの複雑さを回避できる。
これらのサービスは、オンプレミスネットワークと Google Cloud 間のハイブリッド接続を提供する。
| 機能 | Cloud Interconnect(Dedicated) | Cloud Interconnect(Partner) | Cloud VPN(HA VPN) |
|---|---|---|---|
| 接続方式 | 物理光ファイバーによる直接接続 | パートナーネットワーク経由 | パブリックインターネット経由の IPsec VPN |
| 帯域幅 | 10 Gbps、100 Gbps(複数回線構成可) | 50 Mbps 〜 10 Gbps | トンネルあたり最大 3.2 Gbps(ゲートウェイあたり最大 4 トンネル) |
| レイテンシ | 低遅延かつ安定 | 低遅延かつ安定(パートナーに依存) | 変動あり、比較的高い |
| SLA | 99.99%(2 ロケーション以上で 2 回線以上) | 99.9%(2 ロケーション以上で 2 回線以上) | 99.99%(2 インターフェース以上で 2 トンネル以上) |
| コスト | ポート料金 + 下り(外向き)通信料 | パートナー料金 + 下り(外向き)通信料 | VPN ゲートウェイ料金 + 下り(外向き)通信料 |
| セットアップ期間 | 数週間 〜 数か月 | 数日 〜 数週間 | 数分 〜 数時間 |
| 暗号化 | 標準では暗号化なし(レイヤ 2) | 標準では暗号化なし(レイヤ 2) | IPsec による暗号化(レイヤ 3) |
| ユースケース | 高スループット、低遅延、ミッションクリティカルな業務 | 中〜高スループット、迅速な導入 | コスト効率重視、迅速な構築、暗号化通信 |
| ルーティング | Cloud Router を用いた BGP | Cloud Router を用いた BGP | Cloud Router を用いた BGP |
Cloud Armor は、Google Cloud ロードバランサと統合された DDoS 防御および WAF サービスである。
Cloud DNS は、高パフォーマンスなグローバル DNS サービスである。
locionic.com)をホストし、Google のグローバル DNS インフラストラクチャによって管理される。| ネットワーキングコンポーネント | スコープ | プロトコル / レイヤ | スループット | 主な注意点 |
|---|---|---|---|---|
| VPC | グローバル / リージョン | IP(L3) | 高 | ピアリングは非推移的 |
| Cloud NAT | リージョン | TCP / UDP(L4) | 自動スケーリング | ポート枯渇 |
| PSC | グローバル / リージョン | IP(L3) | 高 | プロデューサーの承認が必要 |
| Cloud Interconnect | グローバル | Ethernet(L2) | 10 / 100 Gbps | セットアップに長期間を要する |
| HA VPN | グローバル | IPsec(L3) | 3.2 Gbps / トンネル | インターネット品質への依存 |
| Cloud Armor | グローバル | HTTP/S(L7) | 高 | ロードバランサとの併用が必須 |
| Cloud DNS | グローバル | DNS(L7) | 高 | キャッシュ TTL の影響 |
gcloud CLI レシピ特定のサブネットを持つカスタムモードの VPC ネットワークを作成する。
gcloud compute networks create production-vpc \
--subnet-mode=custom \
--mtu=1460 \
--description="Production VPC for critical workloads"
gcloud compute networks subnets create production-subnet-us-east1 \
--network=production-vpc \
--range=10.10.0.0/20 \
--region=us-east1 \
--enable-private-ip-google-access \
--description="Primary subnet in us-east1 for production VMs"
HA VPN または Cloud Interconnect での動的ルーティング用に Cloud Router を作成する。
gcloud compute routers create production-cloud-router-us-east1 \
--region=us-east1 \
--network=production-vpc \
--asn=64512 \
--description="Cloud Router for hybrid connectivity in us-east1"
HA VPN ゲートウェイと、オンプレミスの VPN デバイスへ接続する 2 本のトンネルを作成する。PEER_IP_0 と PEER_IP_1 は、オンプレミス側 VPN デバイスの外部 IP アドレスに置き換える。
# Create HA VPN Gateway
gcloud compute vpn-gateways create production-ha-vpn-gw-us-east1 \
--network=production-vpc \
--region=us-east1 \
--description="HA VPN Gateway for production VPC"
# Create VPN Tunnel 0
gcloud compute vpn-tunnels create production-vpn-tunnel-0 \
--peer-external-gateway-interface=0 \
--region=us-east1 \
--ike-version=2 \
--shared-secret=YOUR_SHARED_SECRET_0 \
--router=production-cloud-router-us-east1 \
--vpn-gateway=production-ha-vpn-gw-us-east1 \
--interface=0 \
--peer-external-gateway=production-onprem-gw \
--external-traffic-selectors=0.0.0.0/0 \
--local-traffic-selectors=0.0.0.0/0 \
--description="VPN Tunnel 0 to on-premise network"
# Create VPN Tunnel 1
gcloud compute vpn-tunnels create production-vpn-tunnel-1 \
--peer-external-gateway-interface=1 \
--region=us-east1 \
--ike-version=2 \
--shared-secret=YOUR_SHARED_SECRET_1 \
--router=production-cloud-router-us-east1 \
--vpn-gateway=production-ha-vpn-gw-us-east1 \
--interface=1 \
--peer-external-gateway=production-onprem-gw \
--external-traffic-selectors=0.0.0.0/0 \
--local-traffic-selectors=0.0.0.0/0 \
--description="VPN Tunnel 1 to on-premise network"
# Create BGP interfaces and peers on Cloud Router for Tunnel 0
gcloud compute routers add-interface production-cloud-router-us-east1 \
--interface-name=tunnel-0-bgi \
--ip-address=169.254.1.1 \
--mask-length=30 \
--vpn-tunnel=production-vpn-tunnel-0 \
--region=us-east1
gcloud compute routers add-bgp-peer production-cloud-router-us-east1 \
--peer-name=onprem-peer-0 \
--interface=tunnel-0-bgi \
--peer-asn=65501 \
--peer-ip-address=169.254.1.2 \
--region=us-east1 \
--advertisement-mode=DEFAULT_ROUTE_AND_SUBTYPES \
--advertisement-groups=ALL_SUBNETS \
--advertisement-ranges=10.10.0.0/20
# Create BGP interfaces and peers on Cloud Router for Tunnel 1
gcloud compute routers add-interface production-cloud-router-us-east1 \
--interface-name=tunnel-1-bgi \
--ip-address=169.254.2.1 \
--mask-length=30 \
--vpn-tunnel=production-vpn-tunnel-1 \
--region=us-east1
gcloud compute routers add-bgp-peer production-cloud-router-us-east1 \
--peer-name=onprem-peer-1 \
--interface=tunnel-1-bgi \
--peer-asn=65501 \
--peer-ip-address=169.254.2.2 \
--region=us-east1 \
--advertisement-mode=DEFAULT_ROUTE_AND_SUBTYPES \
--advertisement-groups=ALL_SUBNETS \
--advertisement-ranges=10.10.0.0/20
外部 HTTP(S) ロードバランサを保護するための Cloud Armor セキュリティポリシーを作成する。
# Create a new Cloud Armor security policy
gcloud compute security-policies create production-waf-policy \
--description="WAF policy for production web applications"
# Add a rule to block common SQL injection attacks
gcloud compute security-policies rules create 1000 \
--security-policy=production-waf-policy \
--expression="evaluatePreconfiguredExpr('sqli-canary')" \
--action=deny \
--description="Block SQL Injection attempts"
# Add a rule to block XSS attacks
gcloud compute security-policies rules create 1010 \
--security-policy=production-waf-policy \
--expression="evaluatePreconfiguredExpr('xss-canary')" \
--action=deny \
--description="Block Cross-Site Scripting attempts"
# Add a rule to allow traffic from specific IP ranges (e.g., internal networks)
gcloud compute security-policies rules create 10 \
--security-policy=production-waf-policy \
--expression="origin.ip in ['203.0.113.0/24', '198.51.100.0/24']" \
--action=allow \
--description="Allow trusted internal IP ranges"
# Add a default rule to allow all other traffic (must be lowest priority)
gcloud compute security-policies rules create 2147483647 \
--security-policy=production-waf-policy \
--expression="true" \
--action=allow \
--description="Default allow rule"
# Associate the security policy with an external HTTP(S) Load Balancer backend service
gcloud compute backend-services update production-web-backend-service \
--security-policy=production-waf-policy \
--global # Use --region if regional backend service
非同期パターンは、回復性、スケーラビリティ、疎結合なマイクロサービスアーキテクチャを構築するための基本です。Google Cloud は、メッセージパッシング、イベント駆動型インタラクション、ワークフローオーケストレーションを容易にする堅牢なサービススイートを提供しています。
Cloud Pub/Sub は、グローバルに管理され、高いスケーラビリティと耐久性を持つメッセージングサービスです。独立したアプリケーション間で非同期の多対多メッセージングを提供します。
# Create a main topic
gcloud pubsub topics create projects/your-gcp-project/topics/my-main-topic
# Create a DLQ topic
gcloud pubsub topics create projects/your-gcp-project/topics/my-dlq-topic
# Create a subscription with a DLQ policy
gcloud pubsub subscriptions create projects/your-gcp-project/subscriptions/my-subscription \
--topic=projects/your-gcp-project/topics/my-main-topic \
--ack-deadline=30s \
--message-retention-duration=7d \
--dead-letter-topic=projects/your-gcp-project/topics/my-dlq-topic \
--max-delivery-attempts=5
ordering_key 属性を設定する必要があります。# Create a schema definition
gcloud pubsub schemas create my-avro-schema \
--type=AVRO \
--definition='{"type":"record","name":"MyEvent","fields":[{"name":"id","type":"string"},{"name":"timestamp","type":"long"}]}'
# Create a topic with the schema
gcloud pubsub topics create projects/your-gcp-project/topics/my-schema-topic \
--schema=projects/your-gcp-project/schemas/my-avro-schema \
--message-encoding=JSON # or BINARY for Avro/Protobuf
Cloud Tasks は、完全に管理された非同期タスク実行サービスです。タスクをキューに入れて後で実行することができ、堅牢な再試行メカニズム、レート制限、重複排除を提供します。
max-dispatches-per-second): Cloud Tasks キューは、ターゲットサービスへのタスクのディスパッチレートを制御するためのレート制限を設定でき、過負荷を防ぎます。
# Create a queue with rate limits
gcloud tasks queues create my-http-queue \
--max-dispatches-per-second=10 \
--max-concurrent-dispatches=5 \
--location=us-central1
max-attempts、min-backoff、max-backoff、および max-doublings を定義できます。
# Update a queue with retry parameters
gcloud tasks queues update my-http-queue \
--max-attempts=10 \
--min-backoff=5s \
--max-backoff=1h \
--max-doublings=5 \
--location=us-central1
task_id を使用したタスクの重複排除をサポートしています。同じ ID のタスクが 24 時間以内にキューに入れられた場合、それは無視され、重複処理が防止されます。Eventarc は、さまざまなソースからのイベントを Cloud Run、Cloud Functions、または GKE の宛先にルーティングすることで、サービスを接続する統一された方法を提供します。基盤となるトランスポート層として Pub/Sub を利用しています。
# Create an Eventarc trigger for Audit Log events (e.g., GCS object creation)
gcloud eventarc triggers create gcs-audit-trigger \
--destination-run-service=my-event-processor \
--destination-run-region=us-central1 \
--event-filters="type=google.cloud.audit.v1.log.write" \
--event-filters="serviceName=storage.googleapis.com" \
--event-filters="methodName=storage.objects.create" \
--location=us-central1
# Create an Eventarc trigger for Pub/Sub topic messages
gcloud eventarc triggers create pubsub-event-trigger \
--destination-run-service=my-pubsub-consumer \
--destination-run-region=us-central1 \
--matching-criteria="type=google.cloud.pubsub.topic.v1.messagePublished" \
--matching-criteria="topic=my-event-topic" \
--location=us-central1
Cloud Workflows は、Google Cloud サービスと外部 API を組み合わせることができる、YAML または JSON で定義された一連のステップを実行する完全に管理されたオーケストレーションサービスです。
try/except ブロック、再試行、カスタムエラー応答を含む堅牢なエラー処理をサポートしており、回復力のあるプロセス実行を可能にします。Cloud Scheduler は、完全に管理された cron ジョブサービスです。バッチ処理、ビッグデータジョブ、クラウドインフラストラクチャ操作など、ほぼすべてのジョブをスケジュールできます。
# Create a Cloud Scheduler job to hit a Cloud Run service with OIDC authentication
gcloud scheduler jobs create http my-scheduled-job \
--schedule="0 0 * * *" \
--uri="https://my-cloud-run-service-xyz.run.app/process" \
--http-method=GET \
--oidc-service-account-email=my-scheduler-sa@your-gcp-project.iam.gserviceaccount.com \
--oidc-token-audience="https://my-cloud-run-service-xyz.run.app" \
--location=us-central1
Google Cloud Platform (GCP) における最新のデータ分析は、リアルタイムストリーミングからペタバイト規模のバッチ処理、インタラクティブな BI まで、多様なデータワークロードを処理するように設計された、高度にスケーラブルなマネージドサービススイートによって特徴付けられます。アーキテクチャの哲学は、コンピューティングとストレージの分離を中心に据え、独立したスケーリングとコスト最適化を可能にします。
BigQuery は、Google Cloud の完全に管理されたサーバーレスで、高度にスケーラブルなエンタープライズデータウェアハウスです。SQL を使用したペタバイト規模の分析に優れています。
BigQuery のアーキテクチャは、基本的に分離されており、2 つの主要なコンポーネントで構成されています。
これらの手法は、スキャンされるデータ量を制限することで、クエリのパフォーマンスを最適化し、コストを削減します。
DATE または TIMESTAMP 列に基づいてパーティションを自動的に管理します。| 機能 | パーティショニング | クラスタリング |
|---|---|---|
| 粒度 | テーブルセグメント | パーティション内(またはテーブル内)のデータ |
| 列の型 | DATE, TIMESTAMP, DATETIME, INTEGER | 順序付け可能な任意の型 |
| 主な利点 | パーティションをフィルタリングすることでスキャンされるデータを削減 | パーティション内でスキャン/処理されるデータを削減 |
| コストへの影響 | スキャンされるバイトの大幅な削減 | スキャンされるバイトの適度な削減、集計の高速化 |
| 処理順序 | 最初に適用 | 2番目に適用(パーティション内) |
BigQuery BI Engine は、Looker Studio、Looker、カスタムアプリケーションなどの BI ツールからのクエリを含む SQL クエリを高速化するインメモリ分析サービスです。頻繁にアクセスされるデータをカラム型インメモリ形式でキャッシュすることで、ダッシュボードやインタラクティブなレポートに対して秒以下のクエリ応答時間を提供します。BI Engine は BigQuery と透過的に統合されています。
BigQuery Storage Write API は、BigQuery にデータを取り込むための統合 API です。強力なトランザクション保証を備えたストリーミング書き込みとバッチ書き込みの両方をサポートしています。主な機能は次のとおりです。
この API は、ほとんどのユースケースで古いストリーミング挿入 API に代わる、BigQuery への大量、低遅延のデータ取り込みに推奨される方法です。
BigQuery のコンピューティング容量は「スロット」で測定されます。
| 機能 | オンデマンド | 定額料金 (予約) |
|---|---|---|
| コストモデル | スキャンされた TB ごと | 専用スロットの月額/年額固定費用 |
| パフォーマンス | 可変、システム負荷に依存 | 予測可能、専用容量 |
| ワークロードの種類 | スパイク的、予測不能、探索的 | 安定、大量、本番 ETL/BI |
| コスト予測可能性 | 低い | 高い |
| エディション | 該当なし | Standard, Enterprise, Enterprise Plus |
Cloud Dataflow は、Apache Beam パイプラインを実行するための完全に管理されたサービスです。バッチデータ処理とストリーミングデータ処理の両方に統一されたプログラミングモデルを提供します。
Apache Beam は、データ処理パイプラインを定義および実行するためのオープンソースの統一プログラミングモデルです。分散処理の複雑さを抽象化し、開発者がデータ変換ロジックに集中できるようにします。Dataflow は、Beam パイプラインを実行するための Google Cloud のマネージドサービスです。
Beam の核となる強みは、その統一モデルです。同じパイプラインコードをバッチモードとストリーミングモードの両方で実行できるため、開発とメンテナンスが簡素化されます。これは、「ウィンドウ処理」(時間に基づいてデータをグループ化する)や「トリガー」(結果をいつ出力するかを決定する)などの概念を通じて実現されます。
Dataflow は、ストリーミングパイプラインの厳密に1回の処理を含む、強力なデータ処理保証を提供します。これは、障害や再試行が発生した場合でも、各データ要素が正確に1回処理され、出力に反映されることを意味し、金融取引や重要なメトリックにとって不可欠です。これは、チェックポイント処理、永続的な状態、堅牢なフォールトトレランスメカニズムによって実現されます。
Dataflow は、パイプラインのワークロード要件に基づいて、ワーカーインスタンス(VM)の数を自動的にスケーリングします。これにより、手動介入なしに最適なリソース利用とパフォーマンスが保証されます。ピーク時にはスケールアップし、アイドル時にはスケールダウンできるため、コストを最適化できます。
ストリーミングエンジンは、パイプライン実行の一部をワーカー VM からマネージドサービスにオフロードする Dataflow の機能です。これにより、パフォーマンスが向上し、ワーカーのリソース消費が削減され、特に高スループットのストリーミングパイプラインの場合、自動スケーリングが高速化され、状態管理がより効率的になります。
Dataproc は、Apache Spark、Apache Hadoop、Apache Flink、およびその他のオープンソースデータ処理フレームワークを実行するための、完全に管理された、高度にスケーラブルなサービスです。これらのクラスターのデプロイと管理を簡素化します。
Compute Engine 上の Dataproc の一般的なパターンは、エフェメラルクラスターを使用することです。これらのクラスターは、特定のジョブまたは一連のジョブのためにオンデマンドで作成され、作業が完了すると終了します。これにより、コンピューティングリソースがアクティブに使用されている場合にのみ料金を支払うことでコストを最適化します。Dataproc Serverless は、このエフェメラルモデルを本質的に具現化しています。
Dataplex は、組織が分散データを大規模に管理、監視、統制するのに役立つインテリジェントなデータファブリックです。データレイク、データウェアハウス、データマートにわたるデータを統合し、データ管理のための単一の管理画面を提供します。
Dataplex は、以下を含む集中型データガバナンス機能を提供します。
Dataplex は、データメッシュアーキテクチャを実装するための基盤となるコンポーネントです。これにより、組織はデータを製品として扱い、ドメインチームがデータを所有および提供できるようにしながら、ドメイン全体での検出、ガバナンス、相互運用性のための集中プラットフォームを提供できます。Dataplex ゾーン(raw、curated、trusted)は、このドメイン指向の組織を促進します。
Dataplex は、さまざまなソース(BigQuery、Cloud Storage、Cloud SQL など)にわたるデータアセットを自動的に検出し、カタログ化します。スキーマを推論し、データ型を分類し、メタデータを抽出することで、データコンシューマーがデータを簡単に発見し、理解できるようにします。
Dataplex を使用すると、ユーザーはデータ品質ルール(例: 一意性、完全性、有効性)を定義し、その実行をスケジュールできます。時間の経過とともにデータ品質を監視し、逸脱を警告し、データヘルスを追跡するためのダッシュボードを提供することで、分析と ML のデータ信頼性を確保します。
Looker は、Google Cloud が買収した最新のビジネスインテリジェンス (BI) およびデータ分析プラットフォームです。強力なセマンティックモデリングレイヤーと、データ探索および視覚化のための直感的なインターフェースを提供します。
Looker Core は、以下の機能を含む主要な Looker プラットフォームを指します。
Looker Studio は、無料の Web ベースのデータ視覚化およびダッシュボード作成ツールです。ユーザーは、さまざまなデータソース(BigQuery、Google Analytics、Sheets など)に接続し、インタラクティブなレポートやダッシュボードを作成できます。Looker Core のセマンティックモデリングほど強力ではありませんが、迅速な視覚化とインサイトの共有に優れています。
LookML は、Looker の価値提案の要です。ビジネスロジックと定義の「単一の信頼できる情報源」を作成します。LookML でメトリック、ディメンション、リレーションシップを一度定義することで、すべてのレポートとダッシュボードで一貫性が確保されます。このセマンティックレイヤーは、生のデータベースとエンドユーザーの間に位置し、SQL の複雑さを抽象化し、データガバナンスを維持しながらビジネスユーザー向けのセルフサービス分析を可能にします。
| 分析サービス | 基盤となるエンジン | 処理パラダイム | レイテンシ / SLA | 最適なワークロード |
|---|---|---|---|---|
| BigQuery | Dremel (コンピューティング), Capacitor (ストレージ) | SQL クエリエンジン | 数秒から数分 (TB/PB 規模) | ペタバイト規模のデータウェアハウジング、アドホック分析 |
| Cloud Dataflow | Apache Beam | バッチ & ストリーミング ETL | ミリ秒 (ストリーミング), 数分から数時間 (バッチ) | リアルタイム分析、複雑な ETL/ELT、ストリーム処理 |
| Dataproc | Spark, Hadoop, Flink | バッチ & ストリーミング ETL | 数分から数時間 (バッチ), 数秒 (ストリーミング) | カスタム Spark/Hadoop ワークロード、ML、データサイエンス |
| Dataplex | 該当なし (オーケストレーション) | データガバナンス、カタログ | 該当なし | データメッシュ、統合データ管理、データ品質 |
| Looker | LookML (セマンティックレイヤー) | BI、データ探索 | 秒以下 (BI Engine), 数秒 (BigQuery) | セルフサービス BI、統制されたデータ探索、ダッシュボード |
gcloud と bq CLI レシピ1. 日付パーティションテーブルの作成:
bq mk \
--table \
--time_partitioning_field=event_timestamp \
--time_partitioning_type=DAY \
--time_partitioning_expiration=7776000 \
--description "Daily partitioned events table, 90-day expiration" \
my_project_id:my_dataset.events_daily_partitioned \
schema.json
--time_partitioning_field: パーティショニングの TIMESTAMP または DATE 列を指定します。--time_partitioning_type: パーティションの粒度(DAY、HOUR、MONTH、YEAR)を定義します。--time_partitioning_expiration: デフォルトのパーティション有効期限を秒単位で設定します(90 日 = 7776000 秒)。2. 整数パーティションテーブルの作成:
bq mk \
--table \
--range_partitioning_field=user_id \
--range_partitioning_range_start=0 \
--range_partitioning_range_end=1000000 \
--range_partitioning_range_interval=10000 \
--description "Integer partitioned users table" \
my_project_id:my_dataset.users_integer_partitioned \
user_schema.json
--range_partitioning_field: パーティショニングの INTEGER 列を指定します。--range_partitioning_range_start、--range_partitioning_range_end、--range_partitioning_range_interval: 整数範囲を定義します。3. クラスタリングされたテーブルの作成(パーティショニングあり):
bq mk \
--table \
--time_partitioning_field=event_timestamp \
--time_partitioning_type=DAY \
--clustering_fields=user_id,event_type \
--description "Daily partitioned and clustered events table" \
my_project_id:my_dataset.events_clustered \
event_schema.json
--clustering_fields: クラスタリングする 1 つ以上の列を指定します。クエリ最適化のために順序が重要です。4. テーブルを更新してクラスタリングを追加(既存のテーブル):
bq update \
--clustering_fields=product_id,category \
my_project_id:my_dataset.sales_data
1. 予約の作成:
bq mk --reservation \
--project_id=my_project_id \
--location=us-central1 \
--slots=500 \
--ignore_idle_slots \
my_reservation_name
--slots: 予約する専用スロットの数。--ignore_idle_slots: アイドル状態のスロットが自動的に解放されるのを防ぎます。2. 割り当ての作成(プロジェクト/フォルダ/組織への予約の割り当て):
bq mk --assignment \
--project_id=my_project_id \
--location=us-central1 \
--job_type=QUERY \
--assignee_id=projects/my_project_id \
--reservation_id=my_reservation_name \
my_assignment_name
--job_type: 割り当てるジョブの種類(QUERY、LOAD、EXTRACT、BI_ENGINE)。--assignee_id: 予約を割り当てるリソース(プロジェクト、フォルダ、組織)。--reservation_id: 割り当てる予約の名前。3. 予約のリスト表示:
bq ls --reservation --project_id=my_project_id --location=us-central1
4. 割り当てのリスト表示:
bq ls --assignment --project_id=my_project_id --location=us-central1
5. 予約の削除:
bq rm --reservation --project_id=my_project_id --location=us-central1 my_reservation_name
6. 割り当ての削除:
bq rm --assignment --project_id=my_project_id --location=us-central1 my_assignment_name
Google Cloud の AI/ML 製品群(特に Vertex AI)は、データの取り込みと準備からモデルの開発、デプロイ、モニタリングに至るまで、機械学習ライフサイクル全体を網羅する統合プラットフォームを提供する。本ドメインでは、MLOps の原則を重視しつつ、本番環境グレードの AI ソリューション構築にこれらの機能を活用する方法に焦点を当てる。
Vertex AI は Google Cloud の ML サービスを単一のプラットフォームに統合し、ML モデルの開発とデプロイを効率化する。データサイエンティストや ML エンジニア向けに包括的なツールスイートを提供する。
Vertex AI Model Garden は、Google のファーストパーティ製モデルやオープンソースの選択肢を含む、事前学習済みモデル、基盤モデル、およびソリューションを厳選したコレクションである。さまざまな AI タスクの出発点として機能し、迅速なプロトタイピングとデプロイを可能にする。
gemini-1.5-pro-001)を選択する。Vertex AI Endpoints は、ML モデルのデプロイとサービングを行うマネージドサービスである。インフラストラクチャ管理の複雑さを抽象化し、エンジニアがモデルのパフォーマンスに集中できるようにする。
predict() メソッドと load() メソッドを定義した Python スクリプト(predictor.py)。min_replicas: 常時稼働するサービングインスタンスの最小数。ベースラインの可用性を確保し、コールドスタートによるレイテンシを低減する。max_replicas: 許可されるサービングインスタンスの最大数。過剰なプロビジョニングを防ぎ、コストを制御する。NVIDIA_TESLA_T4、NVIDIA_TESLA_V100、NVIDIA_TESLA_A100。TPU_V2、TPU_V3、TPU_V4。# Deploy a custom model to a Vertex AI Endpoint with autoscaling and GPU
MODEL_ID="your-model-id" # Replace with your model ID
ENDPOINT_NAME="my-gpu-endpoint"
PROJECT_ID="your-gcp-project-id"
REGION="us-central1"
MODEL_DISPLAY_NAME="MyCustomModel"
MACHINE_TYPE="n1-standard-4"
ACCELERATOR_TYPE="NVIDIA_TESLA_T4"
ACCELERATOR_COUNT=1
MIN_REPLICAS=1
MAX_REPLICAS=3
gcloud ai endpoints create ${ENDPOINT_NAME} \
--project=${PROJECT_ID} \
--region=${REGION} \
--display-name=${ENDPOINT_NAME}
gcloud ai endpoints deploy-model ${ENDPOINT_NAME} \
--project=${PROJECT_ID} \
--region=${REGION} \
--model=${MODEL_ID} \
--display-name=${MODEL_DISPLAY_NAME} \
--machine-type=${MACHINE_TYPE} \
--accelerator-type=${ACCELERATOR_TYPE} \
--accelerator-count=${ACCELERATOR_COUNT} \
--min-replica-count=${MIN_REPLICAS} \
--max-replica-count=${MAX_REPLICAS} \
--traffic-split=0 # Deploy with 0% traffic initially
Vertex Vector Search(旧 Matching Engine)は、近似最近傍(ANN: Approximate Nearest Neighbor)探索のためのスケーラブルで低レイテンシなサービスである。レコメンデーションシステム、セマンティック検索、異常検知の基盤となる。
# Vertex AI SDK for Vector Search index creation and deployment
from google.cloud import aiplatform
PROJECT_ID = "your-gcp-project-id"
REGION = "us-central1"
INDEX_DISPLAY_NAME = "my-vector-index"
GCS_INPUT_URI = "gs://your-bucket/vectors/" # Path to your vector files (JSONL format)
EMBEDDING_DIMENSIONS = 768 # e.g., for BERT embeddings
APPROX_NEIGHBORS_COUNT = 10 # Number of neighbors to return
aiplatform.init(project=PROJECT_ID, location=REGION)
# Create an index
my_index = aiplatform.MatchingEngineIndex.create_tree_ah_index(
display_name=INDEX_DISPLAY_NAME,
contents_delta_uri=GCS_INPUT_URI,
dimensions=EMBEDDING_DIMENSIONS,
approximate_neighbors_count=APPROX_NEIGHBORS_COUNT,
distance_measure_type="DOT_PRODUCT_DISTANCE", # or "COSINE_DISTANCE", "L2_DISTANCE"
feature_norm_type="NONE", # or "UNIT_L2_NORM"
leaf_node_embedding_count=500,
leaf_nodes_to_search_percent=7,
description="Index for semantic search of product embeddings."
)
# Deploy the index to an endpoint
my_index_endpoint = my_index.deploy_to_endpoint(
display_name=f"{INDEX_DISPLAY_NAME}-endpoint",
machine_type="e2-standard-16",
min_replica_count=1,
max_replica_count=2
)
print(f"Index deployed to endpoint: {my_index_endpoint.resource_name}")
# Example of querying (after deployment)
# query_vector = [0.1, 0.2, ..., 0.9] # Your embedding vector
# response = my_index_endpoint.find_neighbors(
# deployed_index_id=my_index_endpoint.deployed_indexes[0].id,
# queries=[query_vector],
# num_neighbors=5
# )
# print(response)
Vertex Feature Store は、ML 特徴量の管理、サービング、共有を行う一元化されたリポジトリである。オンライン推論における特徴量の一貫性、再利用性、および低レイテンシなサービングに関する課題を解決する。
# Create a Featurestore
FEATURESTORE_ID="my_featurestore"
PROJECT_ID="your-gcp-project-id"
REGION="us-central1"
gcloud ai featurestores create ${FEATURESTORE_ID} \
--project=${PROJECT_ID} \
--region=${REGION} \
--online-serving-config=fixed-node-count=1 # Or auto-scaling
# Create an EntityType
ENTITY_TYPE_ID="user"
gcloud ai featurestores entity-types create ${ENTITY_TYPE_ID} \
--featurestore=${FEATURESTORE_ID} \
--project=${PROJECT_ID} \
--region=${REGION}
# Create a Feature
FEATURE_ID="last_login_timestamp"
VALUE_TYPE="INT64" # Or STRING, BOOL, DOUBLE, BYTES
gcloud ai featurestores features create ${FEATURE_ID} \
--entity-type=${ENTITY_TYPE_ID} \
--featurestore=${FEATURESTORE_ID} \
--project=${PROJECT_ID} \
--region=${REGION} \
--value-type=${VALUE_TYPE}
# Ingest data (example using BigQuery source)
# This is typically done via a batch job or streaming ingestion.
# For batch, you'd define a BigQuery source and import.
# Example:
# gcloud ai featurestores features batch-import \
# --featurestore=${FEATURESTORE_ID} \
# --entity-type=${ENTITY_TYPE_ID} \
# --bigquery-source=bq://your-project.your_dataset.your_table \
# --feature-configs=feature_id=last_login_timestamp,source_field=login_time_col \
# --entity-id-field=user_id_col \
# --project=${PROJECT_ID} \
# --region=${REGION}
Google Cloud は、一般的なタスク向けの事前学習済み特化型 AI API スイートを提供しており、開発者は高度な ML の専門知識がなくても先進的な AI 機能をアプリケーションに統合できる。
# Example: Using gcloud CLI for Document AI Invoice Parser
# Ensure you have a processor created and enabled.
# PROCESSOR_ID="your-processor-id"
# LOCATION="us" # Or eu, global
# INPUT_URI="gs://your-bucket/invoice.pdf"
# OUTPUT_URI="gs://your-bucket/processed_invoices/"
# gcloud docai processors process ${PROCESSOR_ID} \
# --location=${LOCATION} \
# --document-uri=${INPUT_URI} \
# --output-uri=${OUTPUT_URI}
| AI 機能 | サービス / フレームワーク | リアルタイムレイテンシ | トレーニング要件 | 主なビジネスユースケース |
|---|---|---|---|---|
| 基盤モデル | Vertex AI Model Garden | 低(Flash) / 中(Pro) | ファインチューニング(SFT) | コンテンツ生成、要約、チャットボット |
| カスタムモデルサービング | Vertex AI Endpoints | 低 | モデルトレーニング | カスタム ML モデルのデプロイ、リアルタイム推論 |
| ベクトル検索 | Vertex Vector Search | 極低 | エンベディング生成 | セマンティック検索、レコメンデーション、異常検知 |
| 特徴量管理 | Vertex Feature Store | 極低(オンライン) | 特徴量定義 | ML モデルへの一貫した特徴量サービング |
| ドキュメント処理 | Document AI | 中 | 事前学習済み / カスタム | 請求書解析、フォーム抽出、契約書分析 |
| 音声テキスト変換 | Speech-to-Text v2 | 極低(ストリーミング) | 事前学習済み | 音声アシスタント、コールセンター分析、文字起こし |
| テキスト音声変換 | Text-to-Speech(Neural2/Journey) | 極低 | 事前学習済み / カスタム | ナレーション、IVR システム、アクセシビリティ向上 |
| 画像分析 | Vision AI | 低 | 事前学習済み | オブジェクト検出、コンテンツモデレーション、OCR |
クラウド環境においては、効果的なセキュリティ、ID管理、およびゼロトラスト ガバナンスが不可欠である。本ドメインでは、堅牢なセキュリティ体制の構築、最小権限の原則の適用、および機密データの管理を実現するための Google Cloud の主要サービスとアーキテクチャ パターンを扱う。
Cloud Identity and Access Management(IAM)は、「誰が」「どのリソースに対して」「どのようなアクセス権を持つか」を定義する基盤サービスである。最小権限の原則を遵守することが極めて重要であり、ユーザーやサービス アカウントが意図された機能を実行するために必要な権限のみを付与し、それ以上の権限は付与しないようにする。
roles/compute.admin、roles/storage.objectViewer)。ほとんどのシナリオに適しているが、慎重に選択しないと過剰な権限を付与する可能性がある。 # Example custom role definition (YAML for gcloud)
title: "Project Storage Object Reader"
description: "Grants read access to storage objects within a project."
stage: "GA"
includedPermissions:
- "storage.objects.get"
- "storage.objects.list"
カスタムロールを作成するコマンドは以下の通りである。
gcloud iam roles create projectStorageObjectReader \
--project=your-gcp-project-id \
--file=./custom-role.yaml
IAM の条件(IAM Conditions)を使用すると、時間、リソースタグ、API 引数などの属性に基づいて条件付きでロールを付与できる。これにより、単なるロールの割り当てを超えたきめ細かなアクセス制御が可能になる。
# Example: Grant storage.objectViewer role only during business hours (UTC)
gcloud projects add-iam-policy-binding your-gcp-project-id \
--member='user:alice@example.com' \
--role='roles/storage.objectViewer' \
--condition='expression=request.time.getHours() >= 9 && request.time.getHours() under 17 && request.time.getDayOfWeek() >= 1 && request.time.getDayOfWeek() <= 5,title=business_hours_access,description=Access during business hours'
IAM Recommender は IAM ポリシーと使用パターンを分析し、より安全で最小権限の原則に沿ったロールの割り当てを提案する。具体的には以下を特定する。
Recommender のインサイトを定期的に確認して対応することは、強固なセキュリティ体制を維持するための重要な運用プラクティスである。
ワークロード ID 連携は、外部 ID(GitHub Actions、AWS、Azure、オンプレミスの ID プロバイダなど)に対する有効期間の長いサービス アカウント キーの必要性を排除する。代わりに、外部 ID は有効期間の短い認証情報を利用して Google Cloud のサービス アカウントの権限を直接借用(インパーソネート)できる。これにより、キーの漏洩に伴うリスクが大幅に軽減される。
gcloud iam workload-identity-pools create github-actions-pool \
--project=your-gcp-project-id \
--location=global \
--display-name="GitHub Actions Workload Identity Pool"
gcloud iam workload-identity-pools providers create-oidc github-actions-provider \
--project=your-gcp-project-id \
--location=global \
--workload-identity-pool=github-actions-pool \
--display-name="GitHub Actions OIDC Provider" \
--attribute-mapping="google.subject=assertion.sub,attribute.actor=assertion.actor,attribute.repository=assertion.repository" \
--issuer-uri="https://token.actions.githubusercontent.com"
roles/iam.workloadIdentityUser ロールを連携 ID に付与する。これにより、GitHub Actions がサービス アカウントの権限を借用できるようになる。# Get the provider resource name
PROVIDER_ID=$(gcloud iam workload-identity-pools providers describe github-actions-provider \
--project=your-gcp-project-id \
--location=global \
--workload-identity-pool=github-actions-pool \
--format="value(name)")
# Grant the role to a specific GitHub repository's main branch
gcloud iam service-accounts add-iam-policy-binding your-service-account@your-gcp-project-id.iam.gserviceaccount.com \
--project=your-gcp-project-id \
--role="roles/iam.workloadIdentityUser" \
--member="principalSet://iam.googleapis.com/${PROVIDER_ID}/attribute.repository/octo-org/octo-repo" \
--condition="expression=attribute.ref == 'refs/heads/main',title=main_branch_access,description=Allow access only from main branch"
# .github/workflows/deploy.yaml
name: Deploy to GKE
on:
push:
branches:
- main
jobs:
deploy:
runs-on: ubuntu-latest
permissions:
contents: 'read'
id-token: 'write' # This is important for OIDC
steps:
- name: Checkout
uses: actions/checkout@v4
- id: 'auth'
uses: 'google-github-actions/auth@v2'
with:
workload_identity_provider: 'projects/your-gcp-project-id/locations/global/workloadIdentityPools/github-actions-pool/providers/github-actions-provider'
service_account: 'your-service-account@your-gcp-project-id.iam.gserviceaccount.com'
- name: 'Use gcloud CLI'
run: 'gcloud compute instances list --project your-gcp-project-id'
AWS および Azure にも同様のパターンが適用される。
Secret Manager は、API キー、パスワード、証明書、その他の機密データなどのシークレットを保存、管理、アクセスするためのフルマネージド サービスである。セキュリティと運用効率を高めるための堅牢な機能を提供する。
シークレットはプロジェクト内の複数のリージョンに自動的にレプリケートされ、高可用性とディザスタ リカバリを保証する。以下のいずれかを選択できる。
# Create a secret with automatic replication
gcloud secrets create my-api-key \
--project=your-gcp-project-id \
--replication-policy="automatic" \
--data-file=./api-key.txt
# Create a secret with user-managed replication
gcloud secrets create my-regional-secret \
--project=your-gcp-project-id \
--replication-policy="user-managed" \
--locations="us-central1,europe-west1" \
--data-file=./regional-secret.txt
シークレットを更新するたびに新しいバージョンが作成される。これにより以下が可能になる。
# Add a new version to an existing secret
gcloud secrets versions add my-api-key \
--project=your-gcp-project-id \
--data-file=./new-api-key.txt
Secret Manager は、Cloud Functions を呼び出すことで、定義されたスケジュールに従ってシークレットを自動的にローテーションできる。これは、漏洩したシークレットの影響を軽減し、セキュリティのベスト プラクティスを適用する上で極めて重要である。
# Example: Configure a secret to rotate every 30 days
gcloud secrets update my-db-password \
--project=your-gcp-project-id \
--rotation-period="2592000s" \
--rotation-topic="projects/your-gcp-project-id/topics/secret-rotation-topic"
Cloud Run サービスは、シークレットを取得するための明示的なコードを記述することなく、Secret Manager から直接シークレットにアクセスできる。これは、シークレットをボリュームとしてマウントするか、環境変数として注入することで実現される。
gcloud run deploy my-service \
--project=your-gcp-project-id \
--image=gcr.io/cloudrun/hello \
--set-env-vars=API_KEY=SECRET_MANAGER_SECRET_VERSION=my-api-key:latest
gcloud run deploy my-service \
--project=your-gcp-project-id \
--image=gcr.io/cloudrun/hello \
--set-secrets=/etc/secrets/api-key=my-api-key:latest
Cloud Key Management Service(KMS)は、クラウド サービスやアプリケーションの暗号鍵を管理できるクラウドホスト型の鍵管理サービスである。さまざまな鍵のタイプと保護レベルをサポートしている。
Cloud Hardware Security Module(HSM)は、FIPS 140-2 レベル 3 の検証を受けたフルマネージドのハードウェア セキュリティ モジュール サービスである。暗号化操作は HSM 内で実行され、鍵がハードウェアの外部に出ることはないため、最高レベルの鍵保護を提供する。
# Create a key ring
gcloud kms keyrings create my-hsm-keyring \
--project=your-gcp-project-id \
--location=us-central1
# Create an HSM key for encryption/decryption
gcloud kms keys create my-hsm-key \
--project=your-gcp-project-id \
--location=us-central1 \
--keyring=my-hsm-keyring \
--purpose=encryption \
--default-algorithm=google-symmetric-encryption \
--protection-level=hsm
CMEK を使用すると、Cloud KMS で管理されている独自の暗号鍵を使用して、各種 Google Cloud サービス(Cloud Storage、Compute Engine、BigQuery、Cloud SQL など)の保存データを暗号化できる。Google Cloud はデフォルトで Google 管理の暗号鍵を使用して保存データを暗号化するが、CMEK を利用することで制御のレイヤーをさらに追加できる。
# Enable CMEK for a Cloud Storage bucket
gcloud storage buckets update gs://your-bucket-name \
--default-kms-key=projects/your-gcp-project-id/locations/us-central1/keyRings/my-hsm-keyring/cryptoKeys/my-hsm-key
エンベロープ暗号化は、データ暗号化鍵(DEK)でデータを暗号化し、その DEK 自体を鍵暗号化鍵(KEK)で暗号化する手法である。KEK は通常、KMS に保存される。
メリット:
プロセス:
Security Command Center(SCC)は、Google Cloud の一元的な脆弱性および脅威レポート サービスである。セキュリティ チームが Google Cloud アセット全体の脅威を防止、検出、対応するのを支援する。
SCC Standard ティアは基本的なアセット インベントリとセキュリティ ヘルス チェックを提供するが、Premium および Enterprise ティアでは高度な機能が提供される。
Event Threat Detection、Container Threat Detection など)。Container Analysis や Web Security Scanner などのサービスと統合して脆弱性を特定する。SCC は、セキュリティのベスト プラクティスやポリシーに照らし合わせて Google Cloud 環境を継続的に評価する。構成ミス、ポリシー違反、望ましいセキュリティ ポスチャからの逸脱を特定する。
SCC の脅威検出機能は、さまざまなソースと手法を活用する。
CTD は GKE ワークロードを保護するための重要なコンポーネントである。コンテナのランタイム動作に対する深い可視性を提供し、静的解析やアドミッション コントロールをすり抜ける可能性のある脅威を検出する。
Binary Authorization は、信頼されたイメージのみが GKE クラスターまたは Cloud Run サービスにデプロイされることを保証するデプロイ時のセキュリティ制御である。デプロイ前に信頼された機関によってイメージが署名されていることを要求するポリシーを適用する。
証明機関(または「アテスタ」)は、コンテナ イメージに暗号署名するために使用される Cloud KMS キーペアである。イメージをデプロイする前に、設定された証明機関からの有効な証明(アテステーション)が必要となる。
# Create a KMS key ring for attestor
gcloud kms keyrings create my-attestor-keyring \
--project=your-gcp-project-id \
--location=global
# Create a KMS key for signing
gcloud kms keys create my-attestor-key \
--project=your-gcp-project-id \
--location=global \
--keyring=my-attestor-keyring \
--purpose=asymmetric-signing \
--default-algorithm=ec-sign-p256-sha256
# Create an attestor
gcloud container binauthz attestors create my-attestor \
--project=your-gcp-project-id \
--description="Attestor for CI/CD pipeline" \
--kms-key-project=your-gcp-project-id \
--kms-key-location=global \
--kms-keyring=my-attestor-keyring \
--kms-key=my-attestor-key \
--kms-key-version=1
Sigstore プロジェクトの一部である Cosign は、OCI レジストリを使用してコンテナ イメージに署名および検証を行うシンプルな方法を提供する。Binary Authorization とスムーズに統合できる。
cosign sign でイメージに署名する。 # Example: Sign an image with Cosign using a KMS key
# Ensure you have gcloud configured for KMS and cosign installed
export COSIGN_KMS_KEY="gcpkms://projects/your-gcp-project-id/locations/global/keyRings/my-attestor-keyring/cryptoKeys/my-attestor-key/versions/1"
cosign sign --key "${COSIGN_KMS_KEY}" gcr.io/your-gcp-project-id/my-app:latest
Binary Authorization は、GKE クラスターにアドミッション Webhook をデプロイすることで機能する。デプロイ リクエストが行われると、Webhook がそれをインターセプトし、Binary Authorization ポリシーに照らしてイメージをチェックし、デプロイを許可または拒否する。
ポリシー モード:
設定: Binary Authorization ポリシーはプロジェクトレベルで設定され、Binary Authorization が有効になっているそのプロジェクト内のすべての GKE クラスターに適用される。
| セキュリティ コンポーネント | 保護領域 | スコープ | 適用メカニズム | 障害モード |
|---|---|---|---|---|
| Cloud IAM | アクセス制御 | リソース、プロジェクト、組織 | ポリシー バインディング | 過剰な権限付与、不正アクセス |
| ワークロード ID 連携 | ID と認証 | 外部 ID | OIDC/SAML 信頼、SA 権限借用 | 信頼されていない ID による権限借用 |
| Secret Manager | データの機密性 | シークレット | 暗号化、アクセス制御、ローテーション | シークレットの漏洩、不正アクセス |
| Cloud KMS | 暗号鍵 | 鍵、保存データ | 鍵のライフサイクル、HSM、CMEK | 鍵の漏洩、データ露出 |
| Security Command Center | 脅威と脆弱性 | アセット、構成 | 検出、レポート、ポスチャ管理 | 未検出の脅威、構成ミス |
| Binary Authorization | ソフトウェア サプライチェーン | コンテナ イメージ | アドミッション Webhook、証明 | 信頼されていないイメージのデプロイ |
gcloud CLI レシピこのレシピでは、GitHub Actions 用の Workload Identity プールと OIDC プロバイダを作成し、特定の GitHub リポジトリの main ブランチにサービス アカウントの権限を借用する機能を付与する。
# --- Variables ---
GCP_PROJECT_ID="your-production-project-id"
WIF_POOL_ID="github-actions-prod-pool"
WIF_PROVIDER_ID="github-actions-prod-provider"
SERVICE_ACCOUNT_EMAIL="ci-cd-sa@${GCP_PROJECT_ID}.iam.gserviceaccount.com"
GITHUB_ORG="your-github-org"
GITHUB_REPO="your-production-repo"
# 1. Create the Workload Identity Pool
echo "Creating Workload Identity Pool: ${WIF_POOL_ID}..."
gcloud iam workload-identity-pools create "${WIF_POOL_ID}" \
--project="${GCP_PROJECT_ID}" \
--location=global \
--display-name="Production GitHub Actions Pool" \
--description="Pool for production GitHub Actions to access GCP resources." \
--format="value(name)"
# 2. Create the OIDC Provider for GitHub Actions
echo "Creating OIDC Provider: ${WIF_PROVIDER_ID}..."
gcloud iam workload-identity-pools providers create-oidc "${WIF_PROVIDER_ID}" \
--project="${GCP_PROJECT_ID}" \
--location=global \
--workload-identity-pool="${WIF_POOL_ID}" \
--display-name="GitHub Actions OIDC Provider" \
--description="OIDC provider for GitHub Actions from ${GITHUB_ORG}/${GITHUB_REPO}." \
--attribute-mapping="google.subject=assertion.sub,attribute.actor=assertion.actor,attribute.repository=assertion.repository,attribute.ref=assertion.ref" \
--issuer-uri="https://token.actions.githubusercontent.com" \
--format="value(name)"
# 3. Get the full resource name of the provider
WIF_PROVIDER_RESOURCE_NAME=$(gcloud iam workload-identity-pools providers describe "${WIF_PROVIDER_ID}" \
--project="${GCP_PROJECT_ID}" \
--location=global \
--workload-identity-pool="${WIF_POOL_ID}" \
--format="value(name)")
# 4. Grant the service account token creator role to the GitHub identity
# This allows the GitHub Action to impersonate the service account.
# Condition ensures only 'main' branch of the specific repo can impersonate.
echo "Granting roles/iam.workloadIdentityUser to ${SERVICE_ACCOUNT_EMAIL}..."
gcloud iam service-accounts add-iam-policy-binding "${SERVICE_ACCOUNT_EMAIL}" \
--project="${GCP_PROJECT_ID}" \
--role="roles/iam.workloadIdentityUser" \
--member="principalSet://iam.googleapis.com/${WIF_PROVIDER_RESOURCE_NAME}/attribute.repository/${GITHUB_ORG}/${GITHUB_REPO}" \
--condition="expression=attribute.ref == 'refs/heads/main',title=main_branch_access,description=Allow access only from main branch of ${GITHUB_ORG}/${GITHUB_REPO}" \
--format="json"
echo "Workload Identity Federation setup complete for ${GITHUB_ORG}/${GITHUB_REPO}."
echo "Service Account: ${SERVICE_ACCOUNT_EMAIL}"
echo "WIF Pool: ${WIF_POOL_ID}"
echo "WIF Provider: ${WIF_PROVIDER_ID}"
このレシピでは、シークレットを作成し、バージョンを追加した上で、特定のサービス アカウントにそのシークレットへの読み取りアクセス権を付与する。
# --- Variables ---
GCP_PROJECT_ID="your-production-project-id"
SECRET_ID="my-prod-db-password"
SECRET_VALUE_FILE="./prod-db-password.txt" # Ensure this file exists with the secret content
SERVICE_ACCOUNT_EMAIL="db-access-sa@${GCP_PROJECT_ID}.iam.gserviceaccount.com"
# 1. Create the secret with automatic replication
echo "Creating secret: ${SECRET_ID}..."
gcloud secrets create "${SECRET_ID}" \
--project="${GCP_PROJECT_ID}" \
--replication-policy="automatic" \
--labels="env=prod,app=database" \
--data-file="${SECRET_VALUE_FILE}" \
--format="value(name)"
# 2. Add a new version to the secret (if needed, or for initial content)
# Note: The 'create' command above already adds the first version.
# This step is for subsequent updates.
# echo "Adding a new version to secret: ${SECRET_ID}..."
# gcloud secrets versions add "${SECRET_ID}" \
# --project="${GCP_PROJECT_ID}" \
# --data-file="./new-prod-db-password.txt" \
# --format="value(name)"
# 3. Grant Secret Manager Secret Accessor role to the service account
echo "Granting roles/secretmanager.secretAccessor to ${SERVICE_ACCOUNT_EMAIL} for secret ${SECRET_ID}..."
gcloud secrets add-iam-policy-binding "${SECRET_ID}" \
--project="${GCP_PROJECT_ID}" \
--member="serviceAccount:${SERVICE_ACCOUNT_EMAIL}" \
--role="roles/secretmanager.secretAccessor" \
--format="json"
echo "Secret Manager setup complete for secret: ${SECRET_ID}."
echo "Service Account ${SERVICE_ACCOUNT_EMAIL} now has access."
Google Cloud におけるエンタープライズ可観測性は、ロギング、メトリクス、トレーシング、プロファイリングを網羅する全体的な戦略を必要とします。このドメインでは、深い可視性を実現し、コストを最適化し、堅牢な SRE プラクティスを確保するための実証済みの手法を概説します。
Cloud Logging は、ログの収集、保存、分析のための基盤となるサービスです。効果的なログ管理は、デバッグ、監査、セキュリティにとって不可欠です。
ログシンクは、Cloud Logging によって取り込まれたログの宛先を定義します。これにより、ログをさまざまな Google Cloud サービスにルーティングして、保存、分析、またはエクスポートすることができます。
| シンクタイプ | 宛先 | ユースケース | コストへの影響 |
|---|---|---|---|
| BigQuery | データセット | リアルタイム分析、SQL クエリ | 構造化ログに費用対効果が高い |
| Cloud Storage | バケット | 長期アーカイブ、コンプライアンス、バッチ処理 | 生ログストレージのコストが最も低い |
| Pub/Sub | トピック | 外部システムへのリアルタイムストリーミング | カスタム処理を可能にする |
| Cloud Logging | バケット | Logging 内の集中ログストレージ | デフォルト、長期保存にはコストが高い |
大量のデバッグログや詳細ログは、Cloud Logging のコストを大幅に膨らませる可能性があります。除外フィルタは、これらのログが取り込まれて保存されるのを防ぎ、大幅な節約につながります。
戦略: 運用上の価値が最小限であるにもかかわらず、大量に生成されるログエントリを特定します。これらのログを取り込み前に破棄するために、シンクレベルで除外フィルタを作成します。
例: 特定のサービスからの詳細な HTTP アクセスログを除外する。
gcloud logging sinks create my-exclusion-sink \
logging.googleapis.com/projects/my-project/locations/global/buckets/my-exclusion-bucket \
--log-filter='NOT (resource.type="cloud_run_revision" AND jsonPayload.httpRequest.requestUrl=~"/healthz")' \
--description="Excludes health check logs from Cloud Run" \
--exclusion-filters='name="exclude-health-checks",filter="resource.type=\"cloud_run_revision\" AND jsonPayload.httpRequest.requestUrl=~\"/healthz\""' \
--project=my-project
注: --exclusion-filters フラグは非常に重要です。その中の filter は、除外するログを指定します。
ログを BigQuery または Cloud Storage にルーティングすることで、Cloud Logging のデフォルトバケットに長期間保持する場合と比較して、ロギングコストを最大 90% 削減できます。
構造化ログ用の BigQuery: 一貫したスキーマを持つログに最適で、強力な SQL ベースの分析を可能にします。
gcloud logging sinks create bq-app-logs-sink \
bigquery.googleapis.com/projects/my-project/datasets/app_logs_dataset \
--log-filter='resource.type="cloud_run_revision" OR resource.type="gce_instance"' \
--description="Routes application logs to BigQuery for analytics" \
--project=my-project
アーカイブ用の Cloud Storage: 生ログのアーカイブ、コンプライアンス、およびログへのアクセスが infrequent であるかバッチで処理されるシナリオに最適です。
gcloud logging sinks create gcs-audit-logs-sink \
storage.googleapis.com/my-audit-logs-bucket \
--log-filter='logName:"cloudaudit.googleapis.com"' \
--description="Archives all audit logs to Cloud Storage" \
--project=my-project
ログベースのメトリクスを使用すると、ログコンテンツに基づいてカスタムメトリクスを定義できます。これらは、ログにのみ表示される特定のイベント、エラー率、またはビジネス上重要なアクションを監視する上で非常に貴重です。
カウンタメトリクス: 特定のログエントリの発生回数をカウントします。 分布メトリクス: ログエントリから数値データを抽出し、その分布を追跡します。
例: 特定のサービスのエラー("ERROR")レベルのログをカウントする。
gcloud logging metrics create error-log-count \
--description="Counts ERROR severity logs for my-service" \
--log-filter='resource.type="cloud_run_revision" AND resource.labels.service_name="my-service" AND severity="ERROR"' \
--metric-kind=DELTA \
--value-extractor=NONE \
--project=my-project
これらのメトリクスは、Cloud Monitoring でダッシュボードやアラートに使用できます。
Cloud Monitoring は、アプリケーションとインフラストラクチャのパフォーマンス、稼働時間、健全性に関する包括的な可視性を提供します。
Metrics Explorer は、時系列データを視覚化するための主要なインターフェースです。メトリクスのアドホックなクエリ、集計、フィルタリングを可能にします。
主な機能:
mean、sum、max、min、count などの関数を適用します。instance_id、region、service_name)でデータをセグメント化します。MQL は、メトリクスデータのクエリ、集計、変換のための強力で表現力豊かな言語です。複雑な分析や高度なアラート条件に不可欠です。
例: Cloud Run サービスの 99 パーセンタイルレイテンシを、リビジョンごとにグループ化して計算する。
fetch cloud_run_revision
| metric 'run.googleapis.com/request_latencies'
| filter resource.labels.service_name == 'my-service'
| group_by [resource.labels.revision_name],
[value_request_latencies_99_percentile: percentile(value.request_latencies, 99)]
| every 1m
アラートポリシーは、特定のメトリクスしきい値を超えた場合、ログパターンが出現した場合、または稼働時間チェックが失敗した場合に、関係者に通知します。
コンポーネント:
例: GCE インスタンスの CPU 使用率が 5 分間 80% を超えた場合にアラートを出す。
gcloud monitoring policies create \
--display-name="High CPU Utilization on GCE" \
--description="Alerts when GCE instance CPU utilization exceeds 80% for 5 minutes." \
--resource-type="gce_instance" \
--metric="compute.googleapis.com/instance/cpu/utilization" \
--threshold-value=0.8 \
--comparison-operator="COMPARISON_GT" \
--duration="300s" \
--aggregation-cross-series-reducer="REDUCE_MEAN" \
--aggregation-alignment-period="60s" \
--notification-channels="projects/my-project/notificationChannels/1234567890" \
--combiner="OR" \
--project=my-project
稼働時間チェックは、ウェブアプリケーション、API、およびその他のインターネットアクセス可能なリソースの可用性を監視します。外部からの到達可能性に関する重要な洞察を提供します。
タイプ: HTTP、HTTPS、TCP、SSL。 機能: グローバル分散、カスタムヘッダー、コンテンツマッチング、アラート統合。
gcloud monitoring uptime-checks create http \
--display-name="My Service Health Check" \
--resource-type="uptime_url" \
--host="api.locionic.com" \
--port=443 \
--path="/healthz" \
--period="60s" \
--timeout="10s" \
--validate-ssl \
--content-matchers='content="OK",matcher=CONTAINS' \
--notification-channels="projects/my-project/notificationChannels/1234567890" \
--project=my-project
これらの専門ツールは、アプリケーションのパフォーマンス、リソース消費、エラーパターンに関するより深い洞察を提供します。
Cloud Trace は、アプリケーション全体の要求のレイテンシデータを収集し、視覚化します。分散システムにおけるパフォーマンスのボトルネックを特定するのに役立ちます。
主な機能:
Cloud Profiler は、アプリケーションから CPU、ヒープ、その他のリソース消費プロファイルを継続的に収集します。これにより、コードの最もリソースを大量に消費する部分を特定できます。
主な機能:
Error Reporting は、アプリケーションのエラーを集計および分析し、エラーの傾向と発生状況を一元的に表示します。
主な機能:
| 可観測性ツール | テレメトリタイプ | 保持期間 | クエリエンジン | 主なユースケース |
|---|---|---|---|---|
| Cloud Logging | ログ | 設定可能 (デフォルト 30 日) | 高度なフィルタ、ログエクスプローラ | デバッグ、監査、セキュリティ |
| Cloud Monitoring | メトリクス | 6 週間 (生)、25 ヶ月 (集計) | MQL、Metrics Explorer | パフォーマンス、健全性、アラート |
| Cloud Trace | トレース | 30 日 | Trace Explorer | レイテンシ、分散パフォーマンス |
| Cloud Profiler | プロファイル | 30 日 | Profile Explorer | リソース最適化、コードのホットスポット |
| Error Reporting | エラー | 30 日 | Error Explorer | エラー集計、傾向分析 |
gcloud CLI レシピこの例では、すべてのログを Cloud Storage バケットにルーティングするグローバルログシンクを作成しますが、Cloud Run サービスからの特定の詳細ログは除外します。
## 1. Define variables
PROJECT_ID="my-production-project-12345"
GCS_BUCKET_NAME="my-prod-log-archive-bucket"
SINK_NAME="prod-gcs-log-archive-with-exclusions"
EXCLUSION_FILTER_NAME="exclude-cloud-run-health-checks"
EXCLUSION_FILTER_EXPRESSION='resource.type="cloud_run_revision" AND jsonPayload.httpRequest.requestUrl=~"/healthz" AND severity="DEBUG"'
## 2. Create the Cloud Storage bucket (if it doesn't exist)
## Ensure appropriate lifecycle policies are set on the bucket for cost management.
gsutil mb -p "${PROJECT_ID}" "gs://${GCS_BUCKET_NAME}"
## 3. Create the log sink with an exclusion filter
gcloud logging sinks create "${SINK_NAME}" \
"storage.googleapis.com/${GCS_BUCKET_NAME}" \
--log-filter='NOT (resource.type="cloud_run_revision" AND jsonPayload.httpRequest.requestUrl=~"/healthz" AND severity="DEBUG")' \
--description="Archives all logs to GCS, excluding Cloud Run health checks and DEBUG logs." \
--exclusion-filters="name=${EXCLUSION_FILTER_NAME},filter=${EXCLUSION_FILTER_EXPRESSION}" \
--project="${PROJECT_ID}"
## 4. Grant Logging Writer permission to the sink's service account on the GCS bucket
## Get the writer identity from the created sink
WRITER_IDENTITY=$(gcloud logging sinks describe "${SINK_NAME}" --format="value(writerIdentity)" --project="${PROJECT_ID}")
## Grant the permission
gsutil iam ch "user:${WRITER_IDENTITY}:objectCreator" "gs://${GCS_BUCKET_NAME}"
echo "Log sink '${SINK_NAME}' created successfully with exclusion filter."
echo "Ensure the GCS bucket '${GCS_BUCKET_NAME}' has appropriate lifecycle policies."
この例では、アプリケーションエラーのログベースのメトリクスを作成し、エラー率がしきい値を超えた場合にトリガーされるアラートポリシーを作成します。
## 1. Define variables
PROJECT_ID="my-production-project-12345"
METRIC_NAME="app-error-rate"
METRIC_DESCRIPTION="Counts application errors (severity ERROR or CRITICAL) for my-service."
METRIC_FILTER='resource.type="cloud_run_revision" AND resource.labels.service_name="my-service" AND (severity="ERROR" OR severity="CRITICAL")'
ALERT_POLICY_NAME="High Application Error Rate"
ALERT_DESCRIPTION="Alerts when the application error rate for my-service exceeds 5 errors per minute."
NOTIFICATION_CHANNEL_ID="projects/${PROJECT_ID}/notificationChannels/1234567890" # Replace with your actual channel ID
## 2. Create the log-based counter metric
gcloud logging metrics create "${METRIC_NAME}" \
--description="${METRIC_DESCRIPTION}" \
--log-filter="${METRIC_FILTER}" \
--metric-kind=DELTA \
--value-extractor=NONE \
--project="${PROJECT_ID}"
## 3. Create the alerting policy
## Note: The condition uses the custom log-based metric.
gcloud monitoring policies create \
--display-name="${ALERT_POLICY_NAME}" \
--description="${ALERT_DESCRIPTION}" \
--resource-type="global" \
--metric="logging.googleapis.com/user/${METRIC_NAME}" \
--threshold-value=5 \
--comparison-operator="COMPARISON_GT" \
--duration="60s" \
--aggregation-cross-series-reducer="REDUCE_SUM" \
--aggregation-alignment-period="60s" \
--notification-channels="${NOTIFICATION_CHANNEL_ID}" \
--combiner="OR" \
--project="${PROJECT_ID}"
echo "Log-based metric '${METRIC_NAME}' and alerting policy '${ALERT_POLICY_NAME}' created successfully."
echo "Ensure notification channel '${NOTIFICATION_CHANNEL_ID}' is valid."
迅速かつ信頼性の高いソフトウェアデプロイメントには、効果的な CI/CD と合理化された開発者向けデリバリーが不可欠である。Google Cloud は、ソフトウェアリリースライフサイクル全体を自動化、保護、高速化するために設計された統合サービス群を提供している。
Cloud Build は、Google Cloud インフラストラクチャ上でビルドを実行するフルマネージド型の CI/CD プラットフォームである。幅広いソースコードリポジトリ、ビルドステップ、デプロイメントターゲットをサポートしている。
機密性の高いワークロードや、カスタムネットワーク構成(プライベート GKE クラスタへのアクセス、VPN 経由でのオンプレミスリソースへのアクセスなど)を必要とするビルドには、Cloud Build のプライベートワーカープールが不可欠である。これにより、VPC ネットワーク内に専用の分離されたビルド環境が提供される。
| 機能 | 説明 | メリット |
|---|---|---|
| VPC 統合 | VPC に直接接続 | プライベートリソースへのセキュアなアクセス |
| カスタムマシンタイプ | ワーカーの CPU とメモリを指定 | ビルドのパフォーマンスとコストを最適化 |
| IP ホワイトリスト登録 | 下り(外向き)IP アドレスを制御 | セキュリティの強化、ファイアウォールコンプライアンスの遵守 |
| リージョン分離 | 特定のリージョンでワーカーを実行 | データレジデンシーの確保、レイテンシの低減 |
構成スニペット(cloudbuild.yaml):
# cloudbuild.yaml
steps:
- name: 'gcr.io/cloud-builders/docker'
args: ['build', '-t', 'gcr.io/$PROJECT_ID/my-app:$COMMIT_SHA', '.']
options:
workerPool: 'projects/$PROJECT_ID/locations/$REGION/workerPools/my-private-pool'
プライベートワーカープールの作成:
gcloud builds worker-pools create my-private-pool \
--region=$REGION \
--project=$PROJECT_ID \
--network=projects/$PROJECT_ID/global/networks/my-vpc-network \
--peered-network-ip-range=10.128.0.0/20 \
--config-file=worker-pool-config.yaml # Optional: for advanced settings
リポジトリイベント(Git プッシュ、プルリクエストなど)やスケジュールされた間隔に基づいてビルドを自動化する。トリガーは高度な構成が可能であり、ブランチ、タグ、またはファイル変更によるフィルタリングを行える。
| トリガータイプ | イベントソース | ユースケース |
|---|---|---|
| リポジトリ | GitHub、Bitbucket、Cloud Source Repositories | コード変更に対する CI |
| Pub/Sub | カスタム Pub/Sub メッセージ | イベント駆動型ビルド |
| Webhook | 汎用 HTTP POST | 外部システムとの統合 |
| 手動 | コンソール、CLI | アドホックビルド、デバッグ |
GitHub プッシュトリガーの作成:
gcloud builds triggers create github \
--name=my-app-ci-trigger \
--repo-name=my-app-repo \
--repo-owner=my-github-org \
--branch-pattern='^main$' \
--build-config=cloudbuild.yaml \
--project=$PROJECT_ID
ビルド構成内に機密情報をハードコードしてはならない。Cloud Build は Secret Manager と統合されており、ビルドステップの実行中にシークレットを環境変数として安全に挿入できる。
シークレット挿入を含む cloudbuild.yaml:
# cloudbuild.yaml
steps:
- name: 'gcr.io/cloud-builders/gcloud'
entrypoint: 'bash'
args:
- '-c'
- |
echo "Accessing secret: $$MY_API_KEY"
# Use $$MY_API_KEY in your build logic
secretEnv: ['MY_API_KEY']
availableSecrets:
secretManager:
- versionName: projects/$PROJECT_ID/secrets/my-api-key/versions/latest
env: 'MY_API_KEY'
Cloud Build サービスアカウントへの Secret Manager アクセス権の付与:
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
CLOUD_BUILD_SA="${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com"
gcloud secrets add-iam-policy-binding my-api-key \
--role='roles/secretmanager.secretAccessor' \
--member="serviceAccount:${CLOUD_BUILD_SA}" \
--project=$PROJECT_ID
Cloud Build は、過去の実行で生成されたアーティファクトを再利用してビルドを高速化するための多様なキャッシュメカニズムをサポートしている。
| キャッシュタイプ | 説明 | メリット |
|---|---|---|
| Docker レイヤー | Docker イメージレイヤーをキャッシュ | イメージビルドの高速化 |
| ボリュームキャッシュ | ビルドステップ用の永続ボリューム | 依存関係(node_modules、.m2 など)のキャッシュ |
| カスタムキャッシュ | アーティファクトを GCS に保存 | ビルドやプロジェクト間でのキャッシュ共有 |
ボリュームキャッシュの例(cloudbuild.yaml):
# cloudbuild.yaml
steps:
- name: 'gcr.io/cloud-builders/npm'
args: ['install']
volumes:
- name: 'npm-cache'
path: '/root/.npm'
- name: 'gcr.io/cloud-builders/npm'
args: ['test']
volumes:
- name: 'npm-cache'
path: '/root/.npm'
Artifact Registry は Google Cloud 向けのユニバーサルパッケージマネージャーであり、さまざまなアーティファクト形式をサポートするとともに統合セキュリティ機能を提供する。ほとんどのユースケースにおいて、Container Registry の後継となるサービスである。
Artifact Registry は幅広いパッケージ形式をサポートし、アーティファクトのストレージと管理を一元化する。
| 形式 | 説明 | ユースケースの例 |
|---|---|---|
| Docker | コンテナイメージ | マイクロサービス、サーバーレス関数 |
| Maven | Java アーティファクト | Java アプリケーション、ライブラリ |
| npm | Node.js パッケージ | フロントエンド、バックエンドの Node.js アプリ |
| Python | Python パッケージ | Python アプリケーション、データサイエンス |
| Go | Go モジュール | Go アプリケーション、ライブラリ |
| KFP | Kubeflow Pipelines | ML ワークフロー |
Docker リポジトリの作成:
gcloud artifacts repositories create my-docker-repo \
--repository-format=docker \
--location=$REGION \
--description="Docker images for my application" \
--project=$PROJECT_ID
npm リポジトリの作成:
gcloud artifacts repositories create my-npm-repo \
--repository-format=npm \
--location=$REGION \
--description="npm packages for my frontend" \
--project=$PROJECT_ID
Artifact Registry は Container Analysis と統合されており、既知の脆弱性(CVE)がないか Docker イメージを自動的にスキャンする。これにより、CI/CD パイプライン内で重要なセキュリティ分析情報を直接取得できる。
脆弱性スキャンの有効化(リポジトリ単位):
新しい Docker リポジトリでは、脆弱性スキャンがデフォルトで有効になっている。既存のリポジトリの場合は、Container Analysis API が有効になっていることを確認する。
gcloud services enable containeranalysis.googleapis.com
スキャン結果は、Google Cloud コンソールまたは gcloud container images describe(Artifact Registry にプッシュされたイメージの場合)を使用して確認できる。
クリーンアップポリシーを定義することで、ストレージコストを管理し、リポジトリの健全性を維持する。これらのポリシーは、経過期間、バージョン数、タグパターンなどの条件に基づいて、古いアーティファクトやタグなしアーティファクトを自動的に削除する。
クリーンアップポリシーの例(JSON):
{
"cleanupPolicies": [
{
"id": "delete-old-untagged",
"action": "DELETE",
"condition": {
"tagState": "UNTAGGED",
"olderThan": "30d"
}
},
{
"id": "keep-latest-5-tagged",
"action": "DELETE",
"condition": {
"tagState": "TAGGED",
"tagPrefixes": ["v"],
"olderThan": "90d",
"newerThan": "7d",
"versionPruning": {
"keep": 5,
"sortOrder": "NEWEST_PACKAGES"
}
}
}
]
}
クリーンアップポリシーの適用:
gcloud artifacts repositories update my-docker-repo \
--location=$REGION \
--cleanup-policy-file=cleanup-policy.json \
--project=$PROJECT_ID
Cloud Deploy は、さまざまな Google Cloud ランタイム(GKE、Cloud Run、GCE)へのデプロイを自動化するフルマネージド型の継続的デリバリーサービスである。宣言型のデリバリーパイプライン、段階的なロールアウト、統合されたロールバック機能を提供する。
リリースプロセスを一連のステージ(dev、staging、prod など)として定義する。各ステージでは異なる環境をターゲットにし、特定のデプロイメント戦略を適用できる。
デリバリーパイプラインの例(clouddeploy.yaml):
# clouddeploy.yaml
apiVersion: deploy.cloud.google.com/v1
kind: DeliveryPipeline
metadata:
name: my-app-pipeline
description: My application delivery pipeline
serialPipeline:
stages:
- targetId: dev-cluster
profiles: ["dev"]
- targetId: staging-cluster
profiles: ["staging"]
- targetId: prod-cluster
profiles: ["prod"]
strategy:
standard:
postdeploy:
actions: ["verify"] # Example: run integration tests after deployment
ターゲット定義(dev-cluster.yaml):
# dev-cluster.yaml
apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
name: dev-cluster
description: GKE development cluster
gke:
cluster: projects/$PROJECT_ID/locations/$REGION/clusters/dev-gke-cluster
パイプラインとターゲットの登録:
gcloud deploy apply --file=clouddeploy.yaml --region=$REGION --project=$PROJECT_ID
gcloud deploy apply --file=dev-cluster.yaml --region=$REGION --project=$PROJECT_ID
gcloud deploy apply --file=staging-cluster.yaml --region=$REGION --project=$PROJECT_ID
gcloud deploy apply --file=prod-cluster.yaml --region=$REGION --project=$PROJECT_ID
Cloud Deploy はカナリアロールアウトなどの高度なデプロイメント戦略をサポートしており、パフォーマンスを監視しながら新しいバージョンへトラフィックを段階的に移行できる。これによりリスクを最小限に抑え、問題が発生した場合でも迅速なロールバックが可能となる。
clouddeploy.yaml におけるカナリア戦略:
# clouddeploy.yaml (excerpt for prod stage)
- targetId: prod-cluster
profiles: ["prod"]
strategy:
canary:
canaryTargets:
- percent: 25 # Deploy to 25% of instances/pods
# Optional: custom verify/postdeploy actions for canary
- percent: 75 # Deploy to 75% of instances/pods
# Optional: postdeploy actions after full rollout
postdeploy:
actions: ["integration-tests"]
Cloud Deploy は GKE および Cloud Run と統合されており、カナリアデプロイメントにおけるトラフィック分割とリソース割り当てを管理する。
単一ステージ内または複数ステージ間で、複数のターゲット(異なるリージョンやクラスタなど)にリリースをプロモートする。これは、グローバルデプロイメントやブルー/グリーン戦略において極めて重要である。
リリースのプロモート:
gcloud deploy releases promote my-app-release-001 \
--delivery-pipeline=my-app-pipeline \
--to-target=staging-cluster \
--region=$REGION \
--project=$PROJECT_ID
Cloud Deploy はすべてのデプロイメントの履歴を保持している。問題が発生した場合、単一のコマンドで以前の安定したリリースに簡単にロールバックできる。
ロールバックの開始:
gcloud deploy releases rollback my-app-release-001 \
--delivery-pipeline=my-app-pipeline \
--target=prod-cluster \
--to-release=my-app-release-000 \
--region=$REGION \
--project=$PROJECT_ID
このコマンドは、my-app-release-000 に関連付けられたアーティファクトを prod-cluster ターゲットに再デプロイする。
| デリバリーサービス | ライフサイクルステージ | 統合サーフェス | 同時実行数 / 上限 | ベストプラクティス |
|---|---|---|---|---|
| Cloud Build | CI | ソースリポジトリ、Pub/Sub、Webhook | 100 同時ビルド(デフォルト) | 機密ビルドにはプライベートプールを使用、依存関係をキャッシュ |
| Artifact Registry | アーティファクト管理 | Docker、Maven、npm、Python、Go | 高スループット、ペタバイト規模のストレージ | クリーンアップポリシーの実装、脆弱性スキャンの有効化 |
| Cloud Deploy | CD | GKE、Cloud Run、GCE | プロジェクトあたり 20 パイプライン(デフォルト) | 宣言型パイプラインの定義、カナリアデプロイメントの活用 |
gcloud CLI レシピ1. リモートアップストリーム(Docker Hub など)を備えた新しい Docker リポジトリを作成:
gcloud artifacts repositories create my-proxy-repo \
--repository-format=docker \
--location=$REGION \
--description="Proxy for Docker Hub images" \
--mode=REMOTE_REPOSITORY \
--docker-upstream-url=https://registry-1.docker.io \
--project=$PROJECT_ID
2. プロジェクト内のすべてのリポジトリを一覧表示:
gcloud artifacts repositories list \
--project=$PROJECT_ID \
--format="table(name,format,location,createTime)"
3. 特定のリポジトリ内のすべての Docker イメージを一覧表示:
gcloud artifacts docker images list $REGION-docker.pkg.dev/$PROJECT_ID/my-docker-repo \
--project=$PROJECT_ID \
--format="table(IMAGE,TAGS,DIGEST,UPLOAD_TIME)"
4. ダイジェストを指定してイメージを削除(取り消し不可):
gcloud artifacts docker images delete $REGION-docker.pkg.dev/$PROJECT_ID/my-docker-repo/my-app@sha256:abcdef12345... \
--project=$PROJECT_ID \
--delete-tags \
--quiet
1. Cloud Build アーティファクトからリリースを作成:
gcloud deploy releases create my-app-release-$(date +%Y%m%d-%H%M%S) \
--delivery-pipeline=my-app-pipeline \
--images=my-app-image=$REGION-docker.pkg.dev/$PROJECT_ID/my-docker-repo/my-app:$(git rev-parse HEAD) \
--description="Release from latest main branch commit" \
--region=$REGION \
--project=$PROJECT_ID
2. パイプラインのすべてのリリースを一覧表示:
gcloud deploy releases list \
--delivery-pipeline=my-app-pipeline \
--region=$REGION \
--project=$PROJECT_ID \
--format="table(name,createTime,state,targetRenders.targetId.list())"
3. 特定のリースの詳細を取得:
gcloud deploy releases describe my-app-release-001 \
--delivery-pipeline=my-app-pipeline \
--region=$REGION \
--project=$PROJECT_ID
4. リリースを次のステージへ進める(手動プロモーション):
gcloud deploy releases promote my-app-release-001 \
--delivery-pipeline=my-app-pipeline \
--to-target=prod-cluster \
--region=$REGION \
--project=$PROJECT_ID
5. ロールアウトを一時停止(カナリアデプロイメント中など):
gcloud deploy rollouts suspend my-app-release-001-rollout-001 \
--delivery-pipeline=my-app-pipeline \
--release=my-app-release-001 \
--target=prod-cluster \
--region=$REGION \
--project=$PROJECT_ID
6. 一時停止したロールアウトを再開:
gcloud deploy rollouts resume my-app-release-001-rollout-001 \
--delivery-pipeline=my-app-pipeline \
--release=my-app-release-001 \
--target=prod-cluster \
--region=$REGION \
--project=$PROJECT_ID
このセクションでは、Google Cloud Platform(GCP)のコスト最適化に関する7つのゴールデンルールについて詳しく説明します。深い技術的洞察、数式、監査と修正のための実用的なCLIコマンドを提供します。これらのルールは、広範な本番環境での経験から導き出されたものであり、一般的で、しばしば隠れたコストの無駄を排除することを目的としています。
Cloud NATは、ゲートウェイの稼働時間とデータ処理の両方に対して課金されます。アイドル状態のNATゲートウェイは、最小限のトラフィックしか処理していなくても、時間単位の料金が発生します。さらに重要なのは、NATを介して処理されるすべてのデータ(インバウンドとアウトバウンド)が課金されることです。これは、インターネットアクセスを必要とするプライベートIPへのイングレス/エグレスが多いサービスにとって、かなりの隠れたコストになる可能性があります。
コスト構造:
計算式:
Total_NAT_Cost = (Gateway_Hours * 0.0014) + (Processed_GB * 0.045)
監査と修正: データ処理量が少ないが稼働時間が長いNATゲートウェイを特定します。NATゲートウェイの統合、または代替のエグレスパターン(例: パブリックIPへの直接インターネットアクセス、Google APIへのPrivate Google Access)の使用を検討してください。
## List all Cloud NAT gateways and their regions
gcloud compute routers nat list --format="table(name,region,router)"
## Get detailed NAT status, including processed bytes (requires parsing logs or monitoring)
## This command shows configuration, not real-time usage.
## For usage, integrate with Cloud Monitoring metrics: `nat.googleapis.com/bytes_processed`
gcloud compute routers nat describe my-nat-gateway --router=my-router --region=us-central1
アイドル状態のNATの監視:
nat.googleapis.com/bytes_processed のCloud Monitoringアラートを作成し、5分間の合計が24時間連続してしきい値(例: 100 KB)を下回る場合に通知するように設定します。
Cloud Loggingはデフォルトですべてのログを取り込み、月あたり50 GiBの無料枠があります。これを超えると、取り込みはGiBあたり$0.50で課金されます。多くのアプリケーションは、めったにレビューされない冗長なデバッグログを生成しますが、これが取り込みコストに大きく貢献します。
コスト構造:
監査と修正: 大量のログソースを特定します。不要なログを取り込み前に破棄するログ除外シンクを実装するか、アーカイブのために安価なストレージ(例: Cloud Storage)にルーティングします。
## List current log sinks
gcloud logging sinks list --organization=YOUR_ORG_ID --format="table(name,destination,filter)"
## Create an exclusion sink for verbose debug logs from a specific service
## This example excludes logs from 'my-service' with severity DEBUG or INFO
gcloud logging sinks create my-debug-exclusion-sink \
logging.googleapis.com/projects/YOUR_PROJECT_ID/locations/global/buckets/_Default \
--log-filter='resource.type="cloud_run_revision" AND resource.labels.service_name="my-service" AND (severity=DEBUG OR severity=INFO)' \
--description="Exclude verbose debug/info logs from my-service" \
--exclusion-name=my-service-debug-exclude \
--exclude-filter='severity=DEBUG OR severity=INFO'
## To route logs to Cloud Storage for cheaper archival (example)
gcloud logging sinks create my-archive-sink \
gs://my-log-archive-bucket/ \
--log-filter='severity>=INFO' \
--description="Archive all INFO and higher logs to GCS"
ベストプラクティス: アプリケーションレベルでログの冗長性を制御するために、構造化ロギング戦略を実装します。
データ転送コストは、送信元と送信先によって大きく異なります。同じリージョン内でも異なるゾーン間のエグレスは、クロスリージョンエグレスよりも安価です。インターネットエグレスが最も高価です。最適化されていないネットワークトポロジーは、かなりの、しばしば見過ごされがちなエグレス料金につながる可能性があります。
コスト構造(例、リージョン/ティアによって異なる):
0.01 - 0.02。0.08 - 0.12。0.12 - 0.23(ティア制)。監査と修正: VPCフローログを分析して、大量のクロスゾーン/クロスリージョントラフィックを特定します。可能であれば、ゾーンアフィニティのためにアプリケーションデプロイメントを最適化します。VPC間またはリージョン間の内部サービス間通信には、インターネットエグレスを回避するためにPrivate Service Connect (PSC) を使用します。
## Enable VPC Flow Logs for a subnet (if not already enabled)
gcloud compute networks subnets update my-subnet \
--region=us-central1 \
--enable-flow-logs \
--aggregation-interval=INTERVAL_5_SEC \
--flow-sampling=0.5 \
--metadata-fields=SRC_IP,DEST_IP,SRC_PORT,DEST_PORT,PROTOCOL,BYTES_SENT,PACKETS_SENT,START_TIME,END_TIME,SRC_VM,DEST_VM,SRC_ZONE,DEST_ZONE,SRC_REGION,DEST_REGION
## Query Flow Logs in BigQuery (requires exporting Flow Logs to BigQuery)
## Example query to find top cross-zone traffic within a region
bq query --use_legacy_sql=false \
'SELECT
src_zone,
dest_zone,
SUM(bytes_sent) AS total_bytes
FROM
`your_project.your_flow_logs_dataset.vpc_flow_logs_table`
WHERE
src_zone != dest_zone AND src_region = dest_region
GROUP BY
src_zone,
dest_zone
ORDER BY
total_bytes DESC
LIMIT 10'
BigQueryは、分析のために主に2つの料金モデルを提供しています。オンデマンドと固定料金(エディションまたはスロットコミットメント経由)です。オンデマンドはスキャンされたTBあたり$6.25で課金され、大規模で頻繁にクエリされるデータセットでは予測不能で高価になる可能性があります。固定料金は、「スロット」(コンピューティング能力)の特定の数をコミットすることで、予測可能なコストを提供します。
コスト構造:
計算式(オンデマンド):
Total_Query_Cost = (Total_TB_Scanned - Free_Tier_TB) * 6.25
監査と修正:
クエリパターンとスキャンされたデータを分析します。一貫して大量のクエリを実行する場合は、固定料金(エディションまたはスロットコミットメント)の方が費用対効果が高いことがよくあります。実行前にクエリコストを見積もるには、bq コマンドを使用します。
## Estimate bytes scanned for a query (DO NOT RUN THE QUERY)
bq query --dry_run --format=json 'SELECT COUNT(*) FROM `project.dataset.table` WHERE date = CURRENT_DATE()' | jq -r '.statistics.query.totalBytesProcessed'
## Get query history with bytes processed
bq ls -j --all --max_results=100 --format=json | jq -r '.[] | select(.statistics.query.totalBytesProcessed) | {query: .query, bytesProcessed: .statistics.query.totalBytesProcessed}'
## Create a BigQuery reservation (for flat-rate pricing)
## This is a simplified example; actual slot commitment requires careful planning.
gcloud bigquery reservations create my-reservation \
--project=YOUR_PROJECT_ID \
--location=us-central1 \
--slot-capacity=500 \
--edition=STANDARD # Or ENTERPRISE, ENTERPRISE_PLUS
## Assign a project to the reservation
gcloud bigquery reservations assignments create \
--project=YOUR_PROJECT_ID \
--location=us-central1 \
--reservation-id=my-reservation \
--job-type=QUERY \
--assignee-id=projects/YOUR_PROJECT_ID
最適化: テーブルをパーティション分割およびクラスタリングして、スキャンされるデータを削減します。SELECT 必要な列のみを使用します。
Cloud Storageは、ストレージとアクセスに対して異なるコストを持つ様々なストレージクラス(Standard、Nearline、Coldline、Archive)を提供しています。マルチリージョンストレージはリージョンストレージよりも高価です。アクセス頻度の低いデータをマルチリージョンバケットのStandardまたはNearlineに保存することは、一般的なコストの罠です。
コスト構造(例):
監査と修正: オブジェクトライフサイクル管理(OLM)ルールを実装して、オブジェクトをより安価なストレージクラス(例: Coldline、Archive)に自動的に移行させ、最終的には経過時間に基づいて削除します。厳密なリージョン要件があり、アクセス頻度が低いデータの場合は、リージョンArchiveストレージを検討してください。
## Create a lifecycle configuration JSON file (e.g., lifecycle.json)
## This example moves objects older than 30 days to Coldline, then 90 days to Archive, then deletes after 365 days.
cat << EOF > lifecycle.json
{
"rule": [
{
"action": {"type": "SetStorageClass", "storageClass": "COLDLINE"},
"condition": {"age": 30, "isLive": true}
},
{
"action": {"type": "SetStorageClass", "storageClass": "ARCHIVE"},
"condition": {"age": 90, "isLive": true}
},
{
"action": {"type": "Delete"},
"condition": {"age": 365, "isLive": true}
}
]
}
EOF
## Apply the lifecycle configuration to a bucket
gsutil lifecycle set lifecycle.json gs://my-multi-region-bucket
## Check current lifecycle configuration
gsutil lifecycle get gs://my-multi-region-bucket
推奨事項: 特にArchiveストレージは取得コストとレイテンシが高いため、積極的なライフサイクルポリシーを適用する前に、各データセットのアクセスパターンとRTO/RPOを慎重に評価してください。
Cloud SQLインスタンスは、特にCPUとメモリに関して過剰にプロビジョニングされていることが多く、アイドル状態のリソースにつながります。さらに、インスタンスが削除されても、その永続ディスクが自動的に削除されない場合があり、「未アタッチディスク」としてストレージコストが発生し続けます。
コスト構造:
監査と修正: Cloud MonitoringでCloud SQLインスタンスのメトリクス(CPU使用率、メモリ使用率)を定期的に確認します。一貫して低い使用率を示すインスタンスは、サイズを縮小します。インスタンスとともにディスクが削除されるようにプロセスを実装します。
## List Cloud SQL instances and their machine types
gcloud sql instances list --format="table(name,databaseVersion,tier,region,state)"
## Describe an instance to see disk size
gcloud sql instances describe my-sql-instance --format="value(settings.diskSizeGb)"
## Identify unattached disks (requires custom scripting or Cloud Asset Inventory)
## There's no direct `gcloud sql` command for unattached disks.
## You'd typically list all persistent disks and cross-reference with disks attached to running instances.
## Example (conceptual, requires more robust scripting):
## gcloud compute disks list --filter="zone:(us-central1-a OR us-central1-b)" --format="json" | jq -r '.[] | select(.users | length == 0) | .name'
監視: 7日間で平均CPU使用率が10〜15%を下回るCloud SQLインスタンスに対して、Cloud Monitoringアラートを設定します。
これらは、価値を提供せずにコストを発生させ続ける一般的な「ゾンビ」リソースです。
コスト構造:
0.04 - 0.17(タイプによって異なる)。監査と修正: クリーンアップスクリプトを自動化します。リソースを定期的に監査します。
## 1. Find Orphaned Disks (disks not attached to any VM)
## This command lists disks that have no 'users' field, indicating they are unattached.
gcloud compute disks list --filter="-users:*" --format="table(name,zone,sizeGb,type)"
## Delete an orphaned disk (CAUTION: Ensure it's truly orphaned and not needed)
## gcloud compute disks delete my-orphaned-disk --zone=us-central1-a
## 2. Find Unattached Static External IPs
## This command lists static external IP addresses that are not assigned to any resource.
gcloud compute addresses list --filter="status=RESERVED AND -users:*" --format="table(name,region,address,status)"
## Release an unattached static external IP (CAUTION: Ensure it's not needed)
## gcloud compute addresses delete my-unattached-ip --region=us-central1
## 3. Find Idle VMs (requires Cloud Monitoring metrics and custom scripting)
## There's no direct `gcloud` command to list idle VMs based on utilization.
## You need to query Cloud Monitoring for `compute.googleapis.com/instance/cpu/utilization`
## and `compute.googleapis.com/instance/network/received_bytes_count` for VMs.
## Example (conceptual, requires scripting with Cloud Monitoring API):
## For VMs with average CPU < 5% and network < 100KB/hr over 7 days.
## Once identified, stop or delete them:
## gcloud compute instances stop my-idle-vm --zone=us-central1-a
## gcloud compute instances delete my-idle-vm --zone=us-central1-a
自動化: これらの監査コマンドを定期的に(例: Cloud FunctionsまたはCloud Scheduler経由で)実行し、結果を報告するようにスケジュールします。重要な本番環境では、識別 -> 通知 -> 確認 -> 削除という多段階プロセスを実装します。
このセクションでは、GCPで遭遇する一般的な本番環境での落とし穴について詳しく説明し、実際のインシデントの事後分析と技術的な修正策を提供します。これらの「落とし穴」は、スケーリングの制限、設定ミス、またはサービス間の予期せぬ相互作用から生じることがよくあります。
インシデント: 複数のGCPプロジェクトにデプロイされた急速に成長するマイクロサービスアーキテクチャは、サービス間通信のためにVPCピアリングに大きく依存していました。プロジェクトとVPCの数が増えるにつれて、新しいピアリング接続がQUOTA_EXCEEDEDエラー、特に「VPCネットワークピアリング接続数(ネットワークあたり)」クォータ(25)で失敗し始めました。これにより、新しいサービスデプロイが停止し、重要なプロジェクト間通信が妨げられました。
根本原因: ネットワークあたりのVPCピアリング接続のデフォルトクォータである25に達しました。各ピアリング接続は双方向であり、単一の接続はピアリングされた両方のネットワークで1クォータユニットを消費します。N個のプロジェクトでは、フルメッシュピアリングトポロジにはN * (N-1) / 2の接続が必要であり、これは二次関数的に増加します。
影響:
修正/緩和策: Private Service Connect (PSC)
Private Service Connect (PSC) を使用すると、コンシューマはVPCピアリングなしで、プライベートIPアドレスを使用して異なるVPCネットワーク(組織間でも)のサービスにアクセスできます。コンシューマのVPCに専用のプライベートエンドポイントを提供し、プロデューサのVPCのサービスアタッチメントに接続します。
技術的な実装:
プロデューサ側(サービスオーナー):
# Create an Internal TCP/UDP Load Balancer for your service
gcloud compute health-checks create tcp my-service-health-check --port=8080 --region=us-central1
gcloud compute backend-services create my-service-backend --protocol=TCP --health-checks=my-service-health-check --region=us-central1
gcloud compute backend-services add-backend my-service-backend --instance-group=my-instance-group --instance-group-zone=us-central1-a --region=us-central1
gcloud compute forwarding-rules create my-service-forwarding-rule \
--region=us-central1 \
--load-balancing-scheme=INTERNAL \
--network=producer-vpc \
--subnet=producer-subnet \
--address=10.10.10.10 \
--ports=8080 \
--backend-service=my-service-backend
# Create a Service Attachment
gcloud compute service-attachments create my-service-attachment \
--region=us-central1 \
--producer-forwarding-rule=my-service-forwarding-rule \
--connection-preference=ACCEPT_AUTOMATIC \
--description="PSC attachment for my-service"
コンシューマ側(クライアントプロジェクト):
# Create a PSC endpoint (forwarding rule) in the consumer VPC
gcloud compute forwarding-rules create my-psc-endpoint \
--region=us-central1 \
--network=consumer-vpc \
--subnet=consumer-subnet \
--address=10.20.20.20 \
--target-service-attachment=projects/producer-project/regions/us-central1/serviceAttachments/my-service-attachment \
--load-balancing-scheme=INTERNAL_MANAGED \
--ports=8080 \
--description="PSC endpoint to my-service"
結果: PSCは、すべてのネットワークペア間の直接VPCピアリングの必要性を排除し、25ネットワーククォータを効果的に回避します。ネットワークの数に対して二次関数的にではなく、サービスの数に対して線形にスケーリングします。
インシデント: Pub/Subを使用する重要なデータ処理パイプラインが完全に停止しました。メッセージはサブスクライバーに配信されましたが、確認応答されず、繰り返し再配信され、メッセージバックログが増加し、最終的にサブスクライバーの過負荷と障害が発生しました。システムは事実上デッドロック状態でした。
根本原因: サブスクライバーアプリケーションのバグにより、メッセージを受信した後、処理して確認応答を送信する前に、長時間実行されるCPU負荷の高い操作が発生しました。この操作は、デフォルトのPub/Sub ack_deadline(10秒)を時々超えました。期限が過ぎると、Pub/Subはメッセージを再配信しました。バックログが増加するにつれて、より多くのメッセージが再配信され、問題が悪化し、サブスクライバーを圧倒する正のフィードバックループが作成されました。
影響:
修正/緩和策:
ack_deadlineの延長(一時的/緊急):
問題のあるサブスクリプションのack_deadlineを増やして、処理時間を長くします。これは、差し迫ったプレッシャーを軽減するための一時的な修正です。
gcloud pubsub subscriptions update my-subscription \
--ack-deadline=60 # Extend to 60 seconds
modifyAckDeadlineの実装(プログラムによる):
最も堅牢な解決策は、サブスクライバーがメッセージを処理している間にプログラムで確認応答期限を延長することです。これにより、Pub/Subに「まだ作業中なので、まだ再配信しないでください」と伝えます。
# Python Pub/Sub client example
from google.cloud import pubsub_v1
import time
subscriber = pubsub_v1.SubscriberClient()
subscription_path = subscriber.subscription_path("your-project-id", "my-subscription")
def callback(message: pubsub_v1.subscriber.message.Message):
print(f"Received message: {message.data.decode()}")
# Simulate long-running task
time.sleep(5) # Initial processing
message.modify_ack_deadline(30) # Extend deadline by 30 seconds
print("Extended ack deadline.")
time.sleep(10) # More processing
message.ack()
print("Message acknowledged.")
streaming_pull_future = subscriber.subscribe(subscription_path, callback=callback)
print(f"Listening for messages on {subscription_path}...")
with subscriber:
try:
streaming_pull_future.result()
except KeyboardInterrupt:
streaming_pull_future.cancel()
streaming_pull_future.result()
デッドレターキュー(DLQ): サブスクリプションにデッドレターキューを設定します。設定された配信試行回数の後に確認応答に失敗したメッセージはDLQに移動され、無限の再試行とメインサブスクリプションの過負荷を防ぎます。
gcloud pubsub subscriptions update my-subscription \
--dead-letter-topic=projects/your-project-id/topics/my-dlq-topic \
--max-delivery-attempts=5
結果: プログラムによるmodifyAckDeadlineにより、メッセージが時期尚早に再配信されることがなくなります。DLQは、真に処理できないメッセージに対するセーフティネットを提供し、カスケード障害を防ぎ、手動での検査と再処理を可能にします。
インシデント: 低レイテンシのAPI応答用に設計されたCloud Runサービスが、突然のトラフィックバースト中に深刻なレイテンシスパイクとエラー率を経験しました。Cloud Runは自動スケーリングしましたが、バースト中の最初のリクエストはコールドインスタンスにヒットし、高レイテンシにつながりました。この問題は、デフォルトの同時実行設定によって悪化しました。
根本原因: Cloud Runのデフォルトの同時実行数はインスタンスあたり80リクエストです。バースト中に1000リクエストが同時に到着した場合、Cloud Runは10〜15個の新しいインスタンスを起動する可能性があります。ただし、新しいインスタンスごとにコールドスタートに時間がかかります。アプリケーションのコールドスタート時間が長い場合(たとえば、大規模なJavaアプリケーションで5〜10秒)、これらの新しいインスタンスにヒットする最初の数リクエストは高レイテンシを経験します。アプリケーション自体が真に同時実行ではない場合(たとえば、ブロッキングI/Oを使用している、または内部ボトルネックがある場合)、高い同時実行数を設定すると、単一のインスタンスでリクエストがキューに入れられ、レイテンシがさらに増加する可能性があります。
影響:
修正/緩和策:
コールドスタートの最適化:
同時実行数の調整:
gcloud run services update my-service \
--region=us-central1 \
--concurrency=1 # Set concurrency to 1
最小インスタンス数: 厳密なレイテンシ要件を持つ重要なサービスの場合、ウォーム状態を維持するために最小数のインスタンスをプロビジョニングします。これにはコストがかかりますが、コールドスタートは排除されます。
gcloud run services update my-service \
--region=us-central1 \
--min-instances=2 # Keep 2 instances warm
結果: コールドスタートの最適化、適切な同時実行設定、および場合によっては最小インスタンス数の組み合わせにより、Cloud Runサービスは許容可能なレイテンシでバーストトラフィックを処理できます。
インシデント: Compute Engine VM上の長時間実行されるPythonスクリプトとして実装された重要なバッチジョブが、約1時間後に断続的に失敗しました。エラーメッセージは、他のGCPサービス(例:Cloud Storage、BigQuery)にアクセスしようとしたときの認証失敗を示していました。
根本原因: バッチジョブは、サービスアカウントキーファイルを直接、またはVM上のgcloud auth application-default loginを介して暗黙的に認証していました。サービスアカウントキーを使用する場合、取得されるOAuth 2.0アクセストークンはデフォルトで1時間の有効期限があります。アプリケーションはこれらのトークンを更新していなかったため、最初のトークンの有効期限が切れた後に認証失敗が発生しました。
影響:
修正/緩和策:
マネージドサービスアカウント認証情報を使用する(VMに推奨): サービスアカウントキーファイルをダウンロードして管理する代わりに、サービスアカウントをCompute Engine VMインスタンスに直接割り当てます。GCPメタデータサーバーがトークンの更新を自動的に処理します。
# Create a VM with a service account and appropriate scopes
gcloud compute instances create my-batch-vm \
--zone=us-central1-a \
--machine-type=e2-medium \
--image-family=debian-11 \
--image-project=debian-cloud \
--service-account=my-batch-sa@your-project-id.iam.gserviceaccount.com \
--scopes=https://www.googleapis.com/auth/devstorage.read_write,https://www.googleapis.com/auth/bigquery
VM上では、クライアントライブラリを使用するアプリケーションはこれらの認証情報を自動的に取得し、トークンの更新を処理します。
プログラムによるトークン更新(GCPコンピューティング以外の場合): バッチジョブがGCPコンピューティング以外(例:オンプレミス、別のクラウド)で実行され、サービスアカウントキーファイルを使用する場合、アプリケーションコードはトークンの更新を明示的に処理する必要があります。ほとんどのGCPクライアントライブラリは、正しく初期化されていればこれを自動的に行います。最新のクライアントライブラリを使用し、サービスアカウントキーファイルでそれらを初期化していることを確認してください。
# Python example using google-auth library for explicit refresh
from google.oauth2 import service_account
from google.auth.transport.requests import Request
import requests
# Path to your service account key file
KEY_FILE = "path/to/your/service-account-key.json"
SCOPES = ["https://www.googleapis.com/auth/cloud-platform"]
credentials = service_account.Credentials.from_service_account_file(KEY_FILE, scopes=SCOPES)
# The credentials object will automatically refresh tokens when needed
# You can explicitly refresh if necessary, but client libraries usually handle this
if not credentials.valid:
credentials.refresh(Request())
# Use the credentials to make authenticated requests
# Example: Accessing Cloud Storage API
# from google.cloud import storage
# client = storage.Client(credentials=credentials)
結果: GCPコンピューティングでマネージドサービスアカウント認証情報を活用するか、クライアントライブラリがトークンの更新を処理するようにすることで、長時間実行されるジョブは手動介入なしで継続的な認証を維持できます。
インシデント: 分析クエリ用にカラムナエンジンで構成されたAlloyDB for PostgreSQLインスタンスが、複雑な分析ワークロードで断続的なクエリ失敗とパフォーマンス低下を経験しました。ログのエラーメッセージは、カラムナエンジン内の「メモリ不足」状態を示していました。
根本原因: AlloyDBのカラムナエンジンは、分析クエリに最適化されたカラムナ形式でデータを格納します。非常に効率的ですが、特に高カーディナリティ列での結合、集計、ソートなどの操作では、大量のデータ処理に十分なメモリが必要です。プロビジョニングされたインスタンスのメモリは、特定の複雑なクエリのピークメモリ要件に対して不十分であり、カラムナエンジンの内部バッファ内でメモリ枯渇を引き起こしました。これは、カラムナエンジンが独自のメモリ管理を持っているため、標準のPostgreSQLのメモリ枯渇とは異なります。
影響:
修正/緩和策:
カラムナエンジンのメモリ使用量を監視する:
AlloyDBは、カラムナエンジンに特化したメトリクスを提供します。alloydb.googleapis.com/columnar_engine/memory/usageとalloydb.googleapis.com/columnar_engine/memory/total_bytesを監視してください。
クエリの最適化:
WHERE句をできるだけ早く適用します。SELECT *を避けます。インスタンスメモリのスケールアップ: 最も直接的な解決策は、AlloyDBインスタンスのメモリを増やすことです。カラムナエンジンのメモリは、インスタンス全体のメモリの一部です。
# Get current machine type
gcloud alloydb instances describe my-instance --cluster=my-cluster --region=us-central1 --format="value(machineConfig.cpuCount)"
# Update instance to a larger machine type with more memory
# Example: From 4 vCPU, 32GB RAM to 8 vCPU, 64GB RAM
gcloud alloydb instances update my-instance \
--cluster=my-cluster \
--region=us-central1 \
--cpu-count=8 \
--memory=64GB # Note: memory is specified in GB
カラムナエンジンの構成を確認する(高度な設定): AlloyDBはほとんどのカラムナエンジンパラメータを自動的に管理しますが、極端なケースでは、カラムナエンジンのメモリ割り当てに影響を与える可能性のある高度な構成オプションについてGoogle Cloudサポートに相談してください。
結果: カラムナエンジン固有のメトリクスを監視し、クエリを最適化し、インスタンスメモリを適切にスケーリングすることで、AlloyDBインスタンスはメモリ枯渇なしで複雑な分析ワークロードを確実に処理できます。
グローバル企業が、大陸をまたがる予測可能なネットワークパフォーマンスを必要とする、ミッションクリティカルで低レイテンシの金融取引アプリケーションをGCPにデプロイしています。彼らは本番環境のネットワークティアオプションを評価しています。どのGCPネットワークティアを選択すべきで、その理由は何ですか?
Private Service Connect (PSC) と VPC Peering はどちらもVPCネットワーク間のプライベート接続を可能にしますが、その根本的なアーキテクチャモデルとユースケースは大きく異なります。
VPC Peering:
Private Service Connect (PSC):
移行のタイミング: 以下の状況でVPC PeeringからPSCに移行してください。
AlloyDB for PostgreSQL と Cloud SQL for PostgreSQL はどちらもGoogle Cloud上でマネージドなPostgreSQLサービスを提供しますが、それぞれ異なるエンタープライズワークロードと運用要件に最適化されています。
Cloud SQL for PostgreSQL:
AlloyDB for PostgreSQL:
AlloyDBを選ぶべき時: エンタープライズアプリケーションが以下を要求する場合、AlloyDBを選択してください。
BigQuery Editions と オンデマンド料金 は、BigQueryの消費と課金モデルにおいて根本的に異なり、それぞれ異なるエンタープライズ分析費用のパターンに適しています。
オンデマンド料金:
BigQuery Editions (Standard, Enterprise, Enterprise Plus):
予測可能なエンタープライズ分析費用に関する比較:
| 機能 | オンデマンド料金 | BigQuery Editions (容量ベース) |
|---|---|---|
| コストモデル | クエリごとの支払い(スキャンされたバイト数)+ ストレージ | 専用スロットの固定コスト + ストレージ |
| コスト予測可能性 | 低い。クエリアクティビティによって大きく変動 | 高い。コミットされたスロットに基づいて固定 |
| パフォーマンス | 可変。共有リソース、キューイングの可能性あり | 一貫性あり。専用リソース、同時実行性が保証される |
| リソース制御 | 制限あり。動的なスロット割り当て | きめ細かい。プロジェクト/ワークロードへのスロット割り当て、ワークロード管理 |
| 理想的な用途 | アドホック、探索的、小規模/予測不能な負荷 | 本番、重要なBI、大規模ETL、一貫したワークロード |
| コスト効率 | 低使用量、バースト的なワークロードに適している | 予測可能性が重要となる高使用量、一貫した使用量に適している |
予測可能な費用に関する結論: 予測可能なエンタープライズ分析費用に関しては、BigQuery Editionsが断然優れています。クエリコストをスキャンされたデータから切り離し、コンピューティングリソースに対して安定した固定の運用費用を提供します。これにより、企業は正確な予算を立て、予期せぬコストの急増を回避し、専用容量を予約することで重要なワークロードの一貫したパフォーマンスを確保できます。使用量が少ない場合は初期コストが高く見えるかもしれませんが、長期的な予測可能性、パフォーマンス保証、およびワークロード管理機能により、Editionsは本番グレードの分析環境にとって好ましい選択肢となります。
Cloud RunをCloud SQLにパブリックIPを公開せずに接続するための最適なアーキテクチャパターンは、VPCアクセスコネクタとプライベートIP Cloud SQLインスタンスを活用することです。これにより、すべてのトラフィックがGoogleのプライベートネットワーク内に留まり、セキュリティが強化され、レイテンシが削減されます。
アーキテクチャパターン:
Cloud SQLプライベートIPインスタンス:
gcloud sql instances create my-cloudsql-instance \ --database-version=POSTGRES_14 \ --region=us-central1 \ --cpu=2 \ --memory=8GB \ --storage-size=100GB \ --storage-type=SSD \ --network=projects/YOUR_PROJECT_ID/global/networks/YOUR_VPC_NETWORK_NAME \ --no-assign-ip \ --database-flags=cloudsql.iam_authentication=OnServerless VPC Access Connector:
/28 CIDR範囲が必要です。gcloud compute networks vpc-access connectors create my-vpc-connector \ --region=us-central1 \ --network=YOUR_VPC_NETWORK_NAME \ --range=10.8.0.0/28Cloud Runサービス構成:
gcloud run deploy my-cloud-run-service \ --image gcr.io/YOUR_PROJECT_ID/my-app-image \ --platform managed \ --region us-central1 \ --vpc-connector projects/YOUR_PROJECT_ID/locations/us-central1/connectors/my-vpc-connector \ --set-env-vars CLOUDSQL_CONNECTION_NAME=YOUR_PROJECT_ID:us-central1:my-cloudsql-instanceCLOUDSQL_CONNECTION_NAME環境変数を使用してCloud SQL Auth Proxy(セキュアなマネージド接続に推奨)を介して接続します。Auth Proxyは、コネクタを介したセキュアなプライベート接続を自動的に処理します。利点:
Workload Identity Federation は、外部ID(例:AWS、Azure、オンプレミスIdP、またはKubernetesサービスアカウント)が静的なキーを必要とせずにGoogle Cloudサービスアカウントを直接借用できるようにすることで、長期間有効なサービスアカウントJSONキーに関連するセキュリティリスクを根本的に排除します。
サービスアカウントJSONキーの問題点:
Workload Identity Federationがこれを解決する方法:
Workload Identity Federationは、信頼関係と短期間有効な認証情報に基づいて動作します。
外部IDプロバイダー (IdP) の信頼: Google CloudのIAMでIdentity Provider PoolとIdentity Providerを構成します。これにより、Google Cloudと外部IdP(例:AWS IAM、Azure AD、Okta、Kubernetes OIDC)との間に信頼関係が確立されます。どの外部IDが信頼されるかを定義します。
gcloud iam workload-identity-pools create my-pool \ --location=global \ --display-name="My Workload Identity Pool"gcloud iam workload-identity-pools providers create-oidc my-k8s-provider \ --location=global \ --workload-identity-pool=my-pool \ --display-name="My Kubernetes OIDC Provider" \ --issuer-uri="https://container.googleapis.com/v1/projects/PROJECT_ID/locations/REGION/clusters/CLUSTER_NAME"サービスアカウント借用ポリシー: 外部IDに、roles/iam.workloadIdentityUserロールを使用して特定のGoogle Cloudサービスアカウントを借用する権限を付与します。これは、サービスアカウントに対するIAMポリシーバインディングを介して行われます。
gcloud iam service-accounts add-iam-policy-binding my-service-account@PROJECT_ID.iam.gserviceaccount.com \ --role=roles/iam.workloadIdentityUser \ --member="principalSet://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/my-pool/attribute.kubernetes.io/namespace/my-namespace"my-namespaceのmy-poolからの任意のIDは、my-service-accountを借用できる」と述べています。短期間有効な認証情報の交換:
リスクの排除:
要するに、Workload Identity Federationは、信頼を静的な共有シークレット(JSONキー)から動的なフェデレーションIDシステムに移行させ、現代のゼロトラストセキュリティ原則に合致しています。
Google Cloudにエンタープライズアプリケーションをデプロイする前に、セキュリティ、信頼性、費用対効果、および運用準備を確実にするために、厳格なチェックリストが不可欠です。
IAMとアクセス制御の強化:
ネットワークセキュリティとセグメンテーション:
データ暗号化 (CMEKと顧客管理キー):
バックアップと災害復旧 (DR):
可観測性(Observability)とモニタリング:
コスト管理と最適化:
environment、application、cost-center)。Infrastructure as Code (IaC):
セキュリティスキャンと脆弱性管理:
コンプライアンスとガバナンス:
ドキュメントとランブック:
惑星規模のクラウド、特にGoogle Cloudをマスターすることは、単なるインフラストラクチャのプロビジョニングを超え、そのアーキテクチャの基本要素、セキュリティパラダイム、および運用上のベストプラクティスに対する深く実用的な理解を必要とします。このハンドブックは、長年の実戦で培われたエンタープライズ経験を、理論的な概念を超えて、具体的な本番環境レベルの実装へと導く実用的なガイダンスに凝縮することを目的としています。
このハイパースケール環境で成功するための核となる原則は次のとおりです。
惑星規模のクラウドをマスターする旅は継続的です。Google Cloudのイノベーションのペースは絶え間なく、新しいサービスや機能が定期的に導入されています。成功するエンタープライズアーキテクトは、常に学び続け、進化するビジネスニーズとセキュリティ状況に対して新しい機能を常に評価します。ここに概説された原則と実践に従うことで、企業はGoogleのグローバルインフラストラクチャの力を真に活用する、回復力があり、安全で費用対効果の高いソリューションを自信を持って構築、デプロイ、運用できます。課題を受け入れ、正確に構築し、組織をクラウドコンピューティングの未来へと導きましょう。
AI CLIログの整形、Cron式の作成、JWTの解析、chmod権限の計算をオフラインで実行。

2026年におけるCloudRunとGKEの比較について、コスト分析、並行処理、アーキテクチャのトレードオフを、本番環境レベルのアーキテクチャとコード例を交えて解説する包括的なガイドです。
続きを読む
期限切れのGoogleCloudクレジットから最大のROIを引き出すための実践ガイド。一時的なコンピューティングを、期限切れ後のコストゼロで永続的なSEOコンテンツ、ニューラルオーディオ、事前計算済みデータセットに変換する方法を学びましょう。
続きを読む
2026年のServerlessアーキテクチャにおけるコールドスタートレイテンシー、データベース接続枯渇、予期せぬクラウド費用といった隠れた落とし穴と、その対策について解説します。
続きを読む