☁️ STEP 27: プロジェクト② GCPでのデータ基盤構築
アプリログの分析基盤をGCPでリアルタイム処理!
📋 このプロジェクトで構築するもの
- GCSデータレイク(Raw/Processed/Curated層)
- Pub/Subによるリアルタイムログ収集
- Dataflowによるストリーミング処理
- BigQueryへのリアルタイムロード
- パーティショニングとクラスタリング設定
- Looker Studioでのダッシュボード作成
学習時間の目安: 3.5時間
🎯 このプロジェクトのゴール
STEP 26のAWSプロジェクトでは「バッチ処理」でした。今回は「リアルタイム処理」に挑戦します!ログが発生した瞬間にダッシュボードに反映される基盤を作りましょう。
🎯 1. プロジェクト概要
シナリオ
あなたは人気ニュースアプリのデータエンジニアです。「ユーザーの行動をリアルタイムに把握したい」という要求に応えます。
📱 アプリの規模
- 日間アクティブユーザー:100万人
- 1日のイベント数:1,000万件(約115件/秒)
- 要求:リアルタイムでユーザー行動を把握
- 予算:月額$500以内
💡 例え話:バッチ vs リアルタイム
【STEP 26(AWS)= 新聞配達】
・1日1回、まとめて届く
・朝刊を読んで昨日のニュースを知る
・「昨日の売上はいくらだった?」
【STEP 27(GCP)= 速報テロップ】
・ニュースが起きた瞬間に流れる
・リアルタイムで情報が更新される
・「今この瞬間、何人が使っている?」
💡 用途に応じて使い分ける!
・売上レポート → バッチ処理で十分
・障害検知、リアルタイム監視 → ストリーミング処理
アーキテクチャ全体像
🔄 AWS vs GCP サービス対応表
【サービス比較】
┌─────────────────┬──────────────────┬──────────────────┐
│ 役割 │ AWS(STEP 26) │ GCP(STEP 27) │
├─────────────────┼──────────────────┼──────────────────┤
│ オブジェクト │ S3 │ GCS │
│ ストレージ │ │ │
├─────────────────┼──────────────────┼──────────────────┤
│ メッセージング │ Kinesis │ Pub/Sub │
├─────────────────┼──────────────────┼──────────────────┤
│ ETL/処理 │ Glue │ Dataflow │
├─────────────────┼──────────────────┼──────────────────┤
│ DWH │ Redshift │ BigQuery │
├─────────────────┼──────────────────┼──────────────────┤
│ BIツール │ QuickSight │ Looker Studio │
└─────────────────┴──────────────────┴──────────────────┘
【全体アーキテクチャ図】
📱 モバイルアプリ
│
│ ログイベント発生
▼
┌─────────────────────────────────────────────┐
│ Pub/Sub(メッセージキュー) │
│ ・ログを受け取って一時保管 │
│ ・複数の処理先に配信可能 │
└──────────┬──────────────────────────────────┘
│
┌──────┴──────┐
▼ ▼
┌─────────┐ ┌─────────────────────────────┐
│ GCS │ │ Dataflow(ストリーミング) │
│ (Raw) │ │ ・リアルタイムで加工 │
│ 生ログ │ │ ・集計、フィルタリング │
│ 保存 │ └──────────────┬──────────────┘
└─────────┘ │
▼
┌─────────────────┐
│ BigQuery(DWH) │
│ ・リアルタイム │
│ クエリ可能 │
└────────┬────────┘
│
▼
┌─────────────────┐
│ Looker Studio │
│ ・ダッシュボード│
│ ・自動更新 │
└─────────────────┘
📁 2. GCSデータレイク構築
💡 例え話:Pub/Sub = 郵便局
【Pub/Sub = 郵便局のシステム】
■ 従来(直接配送)
・送り主が直接届ける
・受け取り側が不在だと困る
・1対1の通信しかできない
■ Pub/Sub(郵便局経由)
・送り主は郵便局に出すだけ(Publish)
・郵便局が一時保管
・受け取り側は好きな時に取りに行く(Subscribe)
・同じ手紙を複数人に配れる!
💡 メリット:
・送り主と受け取り側が独立
・受け取り側が遅れても大丈夫
・1つのデータを複数の処理先に送れる
STEP 1: GCSバケットの作成
# 変数設定
PROJECT_ID=”your-project-id” # あなたのプロジェクトIDに変更
BUCKET=”${PROJECT_ID}-app-logs”
# バケット作成
gsutil mb -p $PROJECT_ID -c STANDARD -l asia-northeast1 gs://$BUCKET
# フォルダ構造を作成
gsutil cp /dev/null gs://$BUCKET/raw/
gsutil cp /dev/null gs://$BUCKET/processed/
gsutil cp /dev/null gs://$BUCKET/curated/
📝 gsutilコマンドの解説
【各オプションの意味】
gsutil mb -p $PROJECT_ID -c STANDARD -l asia-northeast1 gs://$BUCKET
│ │ │ │ │ │
│ │ │ │ │ └── バケット名
│ │ │ │ └── ロケーション(東京)
│ │ │ └── ストレージクラス
│ │ └── プロジェクトID
│ └── mb = make bucket(バケット作成)
└── Google Cloud Storage CLI
【ストレージクラス】
STANDARD: 通常(頻繁にアクセス)
NEARLINE: 月1回程度のアクセス(30日以上保存)
COLDLINE: 年数回のアクセス(90日以上保存)
ARCHIVE: ほぼアクセスしない(365日以上保存)
STEP 2: ライフサイクル設定
# ライフサイクル設定ファイルを作成
cat > lifecycle.json << 'EOL'
{
"lifecycle": {
"rule": [
{
"action": {"type": "SetStorageClass", "storageClass": "NEARLINE"},
"condition": {"age": 30}
},
{
"action": {"type": "SetStorageClass", "storageClass": "COLDLINE"},
"condition": {"age": 90}
},
{
"action": {"type": "Delete"},
"condition": {"age": 365}
}
]
}
}
EOL
# ライフサイクルを適用
gsutil lifecycle set lifecycle.json gs://$BUCKET
【ライフサイクルの動き】
Day 0-29: STANDARD(通常)
└── 料金: $0.020/GB(東京)
Day 30-89: NEARLINE(低頻度)
└── 料金: $0.010/GB(半額!)
Day 90-364: COLDLINE(超低頻度)
└── 料金: $0.004/GB(1/5!)
Day 365+: 自動削除
└── 料金: $0
💡 AWSのS3ライフサイクルと同じ考え方!
フォルダ構造
【GCSのフォルダ構造】
gs://{project-id}-app-logs/
│
├── raw/ ← 生ログ(そのまま保存)
│ └── year=2025/month=01/day=15/hour=10/
│ └── events_1705301200.json
│
├── processed/ ← 加工済み(クレンジング後)
│ └── year=2025/month=01/day=15/
│ └── events_enriched.parquet
│
└── curated/ ← 分析用(集計済み)
└── daily_summary/
└── 2025-01-15.parquet
💡 STEP 26のS3と同じ3層構造!
📨 3. Pub/Sub設定
STEP 1: トピックとサブスクリプションの作成
# トピック作成(メッセージの送り先)
gcloud pubsub topics create app-logs
# サブスクリプション作成(メッセージの受け取り口)
gcloud pubsub subscriptions create app-logs-to-bigquery \
–topic=app-logs \
–ack-deadline=60
# GCS保存用のサブスクリプションも作成
gcloud pubsub subscriptions create app-logs-to-gcs \
–topic=app-logs \
–ack-deadline=60
📝 トピックとサブスクリプションの関係
【Pub/Subの仕組み】
Publisher(送り主)
│
│ メッセージを送信
▼
┌─────────────────────────────────────┐
│ Topic: app-logs │
│ (メッセージの集約点) │
└──────────────┬──────────────────────┘
│
┌──────────┼──────────┐
▼ ▼ ▼
┌────────┐ ┌────────┐ ┌────────┐
│Sub 1 │ │Sub 2 │ │Sub 3 │
│→BigQuery│→GCS │ │→Dataflow│
└────────┘ └────────┘ └────────┘
💡 1つのトピックに複数のサブスクリプション
→ 同じデータを複数の処理先に送れる!
【ack-deadline=60 の意味】
・60秒以内に処理完了を通知(ack)しないと
・メッセージが再送される(処理失敗とみなす)
STEP 2: テストメッセージ送信(Python)
# テストメッセージ送信スクリプト
import json
from google.cloud import pubsub_v1
from datetime import datetime
import random
project_id = “your-project-id” # あなたのプロジェクトIDに変更
topic_id = “app-logs”
publisher = pubsub_v1.PublisherClient()
topic_path = publisher.topic_path(project_id, topic_id)
# サンプルログデータを生成
log_data = {
‘timestamp’: datetime.utcnow().isoformat(),
‘user_id’: f”user_{random.randint(1, 10000)}”,
‘event_type’: random.choice([‘page_view’, ‘article_read’, ‘share’, ‘comment’]),
‘article_id’: f”article_{random.randint(1, 1000)}”,
‘category’: random.choice([‘politics’, ‘sports’, ‘tech’, ‘entertainment’]),
‘platform’: random.choice([‘iOS’, ‘Android’]),
‘duration_seconds’: random.randint(1, 300)
}
# Pub/Subに送信
message_bytes = json.dumps(log_data).encode(‘utf-8’)
future = publisher.publish(topic_path, data=message_bytes)
print(f”✅ Published message ID: {future.result()}”)
📝 Pub/Subクライアントのコードを詳細解説
【各行の意味を理解しよう】
from google.cloud import pubsub_v1
├── GCPのPub/Subライブラリをインポート
└── pip install google-cloud-pubsub で事前インストール
┌─────────────────────────────────────────────────────────┐
│ publisher = pubsub_v1.PublisherClient() │
├─────────────────────────────────────────────────────────┤
│ Pub/Subにメッセージを送信するクライアントを作成 │
│ ・PublisherClient = 送信者用クライアント │
│ ・SubscriberClient = 受信者用クライアント(別のクラス)│
│ │
│ 認証: │
│ ・環境変数 GOOGLE_APPLICATION_CREDENTIALS に │
│ サービスアカウントキーのパスを設定 │
│ ・GCE/GKE上では自動で認証される │
└─────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────┐
│ topic_path = publisher.topic_path(project_id, topic_id) │
├─────────────────────────────────────────────────────────┤
│ トピックのフルパスを生成 │
│ │
│ 入力: │
│ ・project_id = “my-project” │
│ ・topic_id = “app-logs” │
│ │
│ 出力: │
│ ・”projects/my-project/topics/app-logs” │
│ │
│ なぜ必要? │
│ ・Pub/Sub APIはフルパスで指定する必要がある │
│ ・手動で文字列を組み立てるより安全 │
└─────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────┐
│ message_bytes = json.dumps(log_data).encode(‘utf-8’) │
├─────────────────────────────────────────────────────────┤
│ JSONをバイト列に変換 │
│ │
│ ステップ1: json.dumps(log_data) │
│ ・Pythonの辞書 → JSON文字列に変換 │
│ ・{‘key’: ‘value’} → ‘{“key”: “value”}’ │
│ │
│ ステップ2: .encode(‘utf-8’) │
│ ・文字列 → バイト列に変換 │
│ ・Pub/Subはバイト列しか受け付けない │
│ ・UTF-8は日本語も扱えるエンコーディング │
└─────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────┐
│ future = publisher.publish(topic_path, data=…) │
├─────────────────────────────────────────────────────────┤
│ メッセージを非同期で送信 │
│ │
│ ・publish() = 送信処理を開始(すぐ戻る) │
│ ・future = 送信結果を後で取得するためのオブジェクト │
│ ・非同期 = 送信完了を待たずに次の処理に進める │
│ │
│ なぜ非同期? │
│ ・大量のメッセージを高速に送信できる │
│ ・1件ずつ送信完了を待つと遅くなる │
└─────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────┐
│ future.result() │
├─────────────────────────────────────────────────────────┤
│ 送信完了を待って結果を取得 │
│ │
│ ・送信が完了するまでブロック(待機) │
│ ・成功時: メッセージIDが返る(例: “1234567890”) │
│ ・失敗時: 例外が発生 │
│ │
│ ⚠️ 大量送信時は result() を毎回呼ばない方が高速 │
│ → バッチで送信して最後にまとめて確認する │
└─────────────────────────────────────────────────────────┘
【実行結果】
✅ Published message ID: 1234567890123456
【送信されたデータ例】
{
“timestamp”: “2025-01-15T10:30:00.123456”,
“user_id”: “user_4521”,
“event_type”: “article_read”,
“article_id”: “article_789”,
“category”: “tech”,
“platform”: “iOS”,
“duration_seconds”: 45
}
💡 このデータがリアルタイムでBigQueryに流れる!
⚡ 4. Dataflowストリーミング処理
💡 例え話:Dataflow = 工場のベルトコンベア
【Dataflow = 24時間稼働の工場】
■ バッチ処理(AWS Glue)
・朝9時に工場を開ける
・まとめて処理する
・夜6時に工場を閉める
■ ストリーミング処理(Dataflow)
・24時間ベルトコンベアが動いている
・商品が流れてきたら即座に加工
・止まることなく処理し続ける
💡 Apache Beam = 設計図
Dataflow = 実際の工場
Apache Beamでパイプラインを設計し、
Dataflowで実行する!
Dataflowパイプライン(Python)
# streaming_pipeline.py
import apache_beam as beam
from apache_beam.options.pipeline_options import PipelineOptions, StandardOptions
from apache_beam.io.gcp.pubsub import ReadFromPubSub
from apache_beam.io.gcp.bigquery import WriteToBigQuery
import json
# ログをパースする関数
class ParseLogFn(beam.DoFn):
def process(self, element):
try:
log = json.loads(element.decode(‘utf-8’))
record = {
‘timestamp’: log[‘timestamp’],
‘user_id’: log[‘user_id’],
‘event_type’: log[‘event_type’],
‘article_id’: log[‘article_id’],
‘category’: log.get(‘category’, ‘unknown’),
‘platform’: log[‘platform’],
‘duration_seconds’: log.get(‘duration_seconds’, 0)
}
yield record
except Exception as e:
print(f”Error parsing: {e}”)
# パイプライン設定
options = PipelineOptions([
‘–project=your-project-id’,
‘–region=asia-northeast1’,
‘–runner=DataflowRunner’,
‘–temp_location=gs://your-bucket/temp’,
‘–staging_location=gs://your-bucket/staging’
])
options.view_as(StandardOptions).streaming = True # ストリーミングモード
# BigQueryテーブルスキーマ
table_schema = {
‘fields’: [
{‘name’: ‘timestamp’, ‘type’: ‘TIMESTAMP’},
{‘name’: ‘user_id’, ‘type’: ‘STRING’},
{‘name’: ‘event_type’, ‘type’: ‘STRING’},
{‘name’: ‘article_id’, ‘type’: ‘STRING’},
{‘name’: ‘category’, ‘type’: ‘STRING’},
{‘name’: ‘platform’, ‘type’: ‘STRING’},
{‘name’: ‘duration_seconds’, ‘type’: ‘INTEGER’}
]
}
# パイプライン実行
with beam.Pipeline(options=options) as p:
(p
| ‘Read from Pub/Sub’ >> ReadFromPubSub(
subscription=’projects/your-project-id/subscriptions/app-logs-to-bigquery’
)
| ‘Parse JSON’ >> beam.ParDo(ParseLogFn())
| ‘Write to BigQuery’ >> WriteToBigQuery(
table=’your-project-id:app_analytics.events’,
schema=table_schema,
create_disposition=beam.io.BigQueryDisposition.CREATE_IF_NEEDED,
write_disposition=beam.io.BigQueryDisposition.WRITE_APPEND
)
)
📝 パイプラインの各ステップを解説
【Apache Beamパイプラインの構造】
p | ‘ステップ名’ >> 処理内容
1️⃣ ‘Read from Pub/Sub’ >> ReadFromPubSub(…)
├── Pub/Subからメッセージを読み込む
└── subscriptionで受け取り口を指定
2️⃣ ‘Parse JSON’ >> beam.ParDo(ParseLogFn())
├── 各メッセージに対してParseLogFn()を実行
├── JSON文字列を辞書に変換
└── 必要なフィールドだけ抽出
3️⃣ ‘Write to BigQuery’ >> WriteToBigQuery(…)
├── BigQueryテーブルに書き込む
├── CREATE_IF_NEEDED: テーブルがなければ作成
└── WRITE_APPEND: 既存データに追加
【streaming = True の意味】
・パイプラインが終了せず、ずっと動き続ける
・新しいメッセージが来たら即座に処理
【Dataflow実行結果】
✅ ジョブが開始されました
ジョブ名: streaming-app-logs-20250115-103000
ステータス: Running
リージョン: asia-northeast1
ワーカー数: 1(自動スケーリング)
処理状況:
・入力メッセージ: 1,234/秒
・出力レコード: 1,230/秒
・エラー: 4件(0.3%)
💡 GCPコンソールの「Dataflow」で
リアルタイムに処理状況を確認できる!
🗄️ 5. BigQuery設定
STEP 1: データセットとテーブルの作成
# データセット作成
bq mk –dataset \
–location=asia-northeast1 \
your-project-id:app_analytics
# パーティション&クラスタリングテーブル作成
bq mk –table \
–time_partitioning_field=timestamp \
–time_partitioning_type=DAY \
–clustering_fields=event_type,platform \
your-project-id:app_analytics.events \
timestamp:TIMESTAMP,user_id:STRING,event_type:STRING,article_id:STRING,category:STRING,platform:STRING,duration_seconds:INTEGER
📝 パーティションとクラスタリングの違い
【パーティション = 本棚の棚分け】
・日付ごとにデータを物理的に分割
・WHERE timestamp = ‘2025-01-15’ で
その日のデータだけスキャン
【クラスタリング = 棚の中の整理】
・同じ棚の中で、さらに並び替え
・event_type, platformで並べておく
・WHERE event_type = ‘article_read’ で
さらに効率的に検索
【効果】
パーティションなし: 全データスキャン → $50/クエリ
パーティションあり: 1日分だけ → $0.50/クエリ(1/100!)
クラスタリング追加: さらに絞り込み → $0.10/クエリ
💡 両方設定するのがベストプラクティス!
STEP 2: 分析クエリ
— 1. 時間帯別アクティブユーザー数
SELECT
EXTRACT(HOUR FROM timestamp) AS hour,
COUNT(DISTINCT user_id) AS active_users,
COUNT(*) AS total_events
FROM `your-project-id.app_analytics.events`
WHERE DATE(timestamp) = CURRENT_DATE()
GROUP BY hour
ORDER BY hour;
— 2. 人気記事トップ10
SELECT
article_id,
category,
COUNT(*) AS view_count,
COUNT(DISTINCT user_id) AS unique_readers,
AVG(duration_seconds) AS avg_read_time
FROM `your-project-id.app_analytics.events`
WHERE event_type = ‘article_read’
AND DATE(timestamp) = CURRENT_DATE()
GROUP BY article_id, category
ORDER BY view_count DESC
LIMIT 10;
— 3. プラットフォーム別シェア
SELECT
platform,
COUNT(DISTINCT user_id) AS users,
ROUND(COUNT(DISTINCT user_id) * 100.0 / SUM(COUNT(DISTINCT user_id)) OVER(), 1) AS percentage
FROM `your-project-id.app_analytics.events`
WHERE DATE(timestamp) = CURRENT_DATE()
GROUP BY platform;
【クエリ結果例】
1. 時間帯別アクティブユーザー数
┌──────┬──────────────┬──────────────┐
│ hour │ active_users │ total_events │
├──────┼──────────────┼──────────────┤
│ 9 │ 45,231 │ 123,456 │
│ 10 │ 52,847 │ 145,678 │
│ 11 │ 58,192 │ 167,890 │
│ 12 │ 89,234 │ 256,789 │ ← 昼休みピーク!
└──────┴──────────────┴──────────────┘
3. プラットフォーム別シェア
┌──────────┬─────────┬────────────┐
│ platform │ users │ percentage │
├──────────┼─────────┼────────────┤
│ iOS │ 523,456 │ 52.3 │
│ Android │ 476,544 │ 47.7 │
└──────────┴─────────┴────────────┘
📊 6. Looker Studioダッシュボード
ダッシュボード設計
【アプリログ分析ダッシュボード構成】
┌────────────────────────────────────────────────────────┐
│ 📱 ニュースアプリ ログ分析ダッシュボード │
├────────────────────────────────────────────────────────┤
│ 【リアルタイム指標】 │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ 52,847 │ │1,234/秒 │ │ 45秒 │ │ 52:48 │ │
│ │現在の │ │イベント │ │平均滞在 │ │iOS: │ │
│ │ユーザー │ │発生数 │ │時間 │ │Android │ │
│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │
├────────────────────────────────────────────────────────┤
│ 【時間帯別アクセス推移】 │
│ ┌────────────────────────────────────────────────┐ │
│ │ ╱╲ │ │
│ │ ╱ ╲ ╱╲ ← 昼休み&夜ピーク │ │
│ │ ╱ ╲ ╱ ╲ │ │
│ │╱ ╲╱ ╲ │ │
│ └────────────────────────────────────────────────┘ │
│ 9 10 11 12 13 14 15 16 17 18 19 20 │
├────────────────────────────────────────────────────────┤
│ 【人気記事TOP5】 │ 【カテゴリ別】 │
│ 1. 速報:〇〇 12,345件 │ 🍰 円グラフ │
│ 2. 特集:△△ 8,765件 │ ・スポーツ 35% │
│ 3. 解説:□□ 6,543件 │ ・政治 25% │
│ 4. コラム:◇◇ 5,432件 │ ・テック 20% │
│ 5. インタビュー 4,321件 │ ・エンタメ 20% │
└────────────────────────────────────────────────────────┘
Looker Studio接続手順
【Looker Studio設定手順】
1. Looker Studioにアクセス
https://lookerstudio.google.com/
2. データソースの追加
・「作成」→「データソース」
・「BigQuery」を選択
・プロジェクト → データセット → テーブルを選択
・「接続」をクリック
3. レポート作成
・「作成」→「レポート」
・データソースを選択
・グラフを配置
4. グラフの種類
・スコアカード: KPI数値(ユーザー数など)
・時系列グラフ: 時間推移
・円グラフ: 構成比
・テーブル: ランキング
・地図: 地域別(日本地図)
5. 自動更新設定
・右上「編集」→「レポート設定」
・「データの更新頻度」を設定
・15分、1時間、12時間から選択
💡 BigQueryに直接クエリするので、
常に最新データが表示される!
✅ QuickSight vs Looker Studio
【比較】
┌───────────────┬─────────────────┬─────────────────┐
│ 項目 │ QuickSight │ Looker Studio │
├───────────────┼─────────────────┼─────────────────┤
│ 料金 │ $9/月〜 │ 無料! │
│ 接続先 │ AWS中心 │ GCP中心 │
│ 操作性 │ やや複雑 │ シンプル │
│ 共有 │ ユーザー課金 │ URLで無料共有 │
└───────────────┴─────────────────┴─────────────────┘
💡 Looker Studioの最大の魅力は「無料」!
BigQueryとの相性も抜群
💰 7. コスト最適化
| サービス | 最適化内容 | 削減前 | 削減後 |
|---|---|---|---|
| BigQuery | パーティション+クラスタリング | $200/月 | $50/月 |
| GCS | ライフサイクル(30日→NEARLINE) | $100/月 | $60/月 |
| Dataflow | オートスケーリング設定 | $300/月 | $150/月 |
| Pub/Sub | 不要なサブスクリプション削除 | $50/月 | $30/月 |
| Looker Studio | (無料) | $0 | $0 |
【コスト見積もり比較】
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
■ 最適化前: $650/月
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
├── Dataflow(常時2ワーカー) $300
├── BigQuery(フルスキャン) $200
├── GCS(STANDARD) $100
└── Pub/Sub $50
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
■ 最適化後: $290/月 ✅目標達成!
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
├── Dataflow(オートスケール) $150
├── BigQuery(パーティション) $50
├── GCS(ライフサイクル) $60
└── Pub/Sub $30
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
削減額: $360/月(55%削減!)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
コストアラート設定
# コストアラート設定(予算超過を通知)
gcloud billing budgets create \
–billing-account=XXXXX-XXXXX-XXXXX \
–display-name=”App Logs Budget” \
–budget-amount=500USD \
–threshold-rule=percent=50 \
–threshold-rule=percent=80 \
–threshold-rule=percent=100
📝 8. STEP 27 のまとめ
✅ このプロジェクトで構築したもの
- GCSデータレイク:Raw/Processed/Curatedの3層構造
- Pub/Sub:リアルタイムログ収集(メッセージキュー)
- Dataflow:ストリーミング処理(Apache Beam)
- BigQuery:パーティション+クラスタリングで高速DWH
- Looker Studio:無料のBIダッシュボード
- コスト最適化:月額$650→$290に削減(55%減)
🔄 STEP 26(AWS) vs STEP 27(GCP)の違い
【処理方式の違い】
STEP 26: バッチ処理(日次でまとめて処理)
STEP 27: ストリーミング処理(リアルタイム処理)
【アーキテクチャの違い】
STEP 26: S3 → Glue → Redshift → QuickSight
STEP 27: Pub/Sub → Dataflow → BigQuery → Looker Studio
【コストモデルの違い】
AWS: Redshiftは時間課金(稼働中は常に課金)
GCP: BigQueryはクエリ課金(使った分だけ)
💡 どちらが良いかはユースケース次第!
・定型レポート中心 → AWS
・アドホック分析中心 → GCP
💡 次のステップへ
STEP 26(AWS)とSTEP 27(GCP)で、両方のクラウドでデータ基盤を構築しました!
次のSTEP 28では、ハイブリッドクラウド設計に挑戦します。
AWSとGCPを連携させて、両方の長所を活かした設計を学びましょう!
❓ よくある質問
Q1: Pub/Subの代わりにKafkaを使えますか?
はい、可能です。GCPではManaged Kafkaも提供されています。ただし、GCPネイティブで使うならPub/Subの方がシンプルで、他のGCPサービスとの連携も簡単です。
Q2: Dataflowは常に動かしておく必要がありますか?
ストリーミング処理なら常時稼働が必要です。ただし、オートスケーリングでワーカー数を自動調整し、夜間は最小構成にすることでコストを抑えられます。バッチ処理なら、スケジュール実行も可能です。
Q3: BigQueryのスロット予約は必要ですか?
小規模なら不要です。オンデマンド課金($5/TB)で十分です。月額$10,000以上のクエリコストが発生する場合は、スロット予約(定額制)の方がお得になります。
Q4: Looker StudioとLookerは違うものですか?
はい、別製品です。Looker Studioは無料のBIツール(旧Google Data Studio)。Lookerは有料のエンタープライズBIプラットフォームで、より高度な機能(LookML、データモデリング)があります。
Q5: GCPの方がAWSより安いですか?
ケースバイケースです。BigQueryはクエリ課金で小規模なら安いですが、大規模クエリでは高くなることも。Dataflowは常時稼働が必要でコストがかかります。ユースケースに応じて比較しましょう。
学習メモ
クラウドデータ基盤(AWS・GCP) - Step 27
📋 過去のメモ一覧
▼