Google Cloud Platform (GCP)

クラウドプラットフォームデータ分析機械学習KubernetesBigQueryTensorFlow

クラウドプラットフォーム

概要

Google Cloud Platform（GCP）は、Googleのクラウドインフラストラクチャとサービスです。機械学習、データ分析、Kubernetesに強みを持ち、BigQuery、TensorFlowなど革新的なサービスを提供しています。AI・機械学習分野でのリーダーシップを発揮し、データドリブンな企業やスタートアップでの採用が増加しています。Kubernetesの開発元としての強みも活かし、コンテナ化とマイクロサービスアーキテクチャの分野で優位性を持っています。

詳細

GCPは2008年にApp Engineから開始し、現在では35以上のリージョンで展開され、Googleのコアテクノロジーをクラウドサービスとして提供しています。特にデータ分析（BigQuery）、機械学習（Vertex AI）、Kubernetesマネージドサービス（GKE）において業界をリードしています。2025年の注目機能として、Vertex AIでの新しいマルチモーダルモデル対応、BigQueryでの強化されたマルチクラウド分析機能、Cloud Runでの第3世代実行環境、Document AI APIの拡張などがあります。

主な特徴

機械学習: Vertex AI、AutoML、TensorFlowによる包括的なMLプラットフォーム
データ分析: BigQuery、Dataflow、Pub/Subによるリアルタイム分析
コンテナ: GKE（Google Kubernetes Engine）による業界最高レベルのKubernetes体験
サーバーレス: Cloud Run、Cloud Functionsによる完全マネージドコンピューティング
グローバルネットワーク: Googleの世界規模のインフラストラクチャ

2025年の最新機能

Vertex AI: マルチモーダル対応とより柔軟なモデル展開
BigQuery: 強化されたクロスクラウド分析とAI統合
Cloud Run: 第3世代実行環境でパフォーマンス向上
Document AI: より高精度な文書解析機能
Security Command Center: 強化されたクラウドセキュリティ監視

メリット・デメリット

メリット

データ分析・機械学習における業界最高レベルの技術力
Kubernetesネイティブなコンテナプラットフォーム
BigQueryによる高速で大規模なデータ分析
シンプルで一貫性のあるAPI設計
従量課金制による優れたコストパフォーマンス
Googleの高品質なグローバルネットワークインフラ
環境配慮：カーボンニュートラルなクラウドサービス

デメリット

AWSと比較してサービス数が少ない
エンタープライズ向けサポートがAWS・Azureより弱い
一部の地域でのデータセンター数が限定的
サードパーティツールとの統合がAWSより少ない
ドキュメントの日本語化が不十分な場合がある
歴史が浅いため、レガシーシステムとの統合に課題

参考ページ

書き方の例

1. 基本セットアップとアカウント設定

# Google Cloud SDKのインストール
curl https://sdk.cloud.google.com | bash
exec -l $SHELL

# gcloudの初期化
gcloud init

# 認証設定
gcloud auth login
gcloud auth application-default login

# プロジェクトの作成
gcloud projects create my-project-id --name="My Project"

# プロジェクトの設定
gcloud config set project my-project-id

# 利用可能なリージョン一覧
gcloud compute regions list

# デフォルトリージョンの設定
gcloud config set compute/region asia-northeast1
gcloud config set compute/zone asia-northeast1-a

# 現在の設定確認
gcloud config list

# 請求アカウントの確認
gcloud billing accounts list

# 請求アカウントをプロジェクトにリンク
gcloud billing projects link my-project-id --billing-account=BILLING_ACCOUNT_ID

# APIの有効化
gcloud services enable compute.googleapis.com
gcloud services enable container.googleapis.com
gcloud services enable bigquery.googleapis.com

2. コンピュートサービス（VM、コンテナ）

# Compute Engine VM作成（Google Cloud Python SDK）
from google.cloud import compute_v1
import time

# クライアントの初期化
instances_client = compute_v1.InstancesClient()
networks_client = compute_v1.NetworksClient()
firewalls_client = compute_v1.FirewallsClient()

project_id = "my-project-id"
zone = "asia-northeast1-a"
region = "asia-northeast1"

# ファイアウォールルールの作成
firewall_rule = compute_v1.Firewall()
firewall_rule.name = "allow-web-traffic"
firewall_rule.direction = "INGRESS"
firewall_rule.allowed = [
    compute_v1.Allowed(I_p_protocol="tcp", ports=["80", "443", "22"])
]
firewall_rule.source_ranges = ["0.0.0.0/0"]
firewall_rule.target_tags = ["web-server"]

operation = firewalls_client.insert(
    project=project_id,
    firewall_resource=firewall_rule
)

print(f"Creating firewall rule: {firewall_rule.name}")

# VM インスタンスの作成
instance = compute_v1.Instance()
instance.name = "web-server-vm"
instance.machine_type = f"zones/{zone}/machineTypes/e2-medium"

# ブートディスクの設定
disk = compute_v1.AttachedDisk()
initialize_params = compute_v1.AttachedDiskInitializeParams()
initialize_params.source_image = "projects/ubuntu-os-cloud/global/images/family/ubuntu-2004-lts"
initialize_params.disk_size_gb = 20
initialize_params.disk_type = f"zones/{zone}/diskTypes/pd-standard"
disk.initialize_params = initialize_params
disk.auto_delete = True
disk.boot = True
instance.disks = [disk]

# ネットワーク設定
network_interface = compute_v1.NetworkInterface()
network_interface.network = "global/networks/default"
access_config = compute_v1.AccessConfig()
access_config.type_ = compute_v1.AccessConfig.Type.ONE_TO_ONE_NAT.name
access_config.name = "External NAT"
network_interface.access_configs = [access_config]
instance.network_interfaces = [network_interface]

# メタデータとスタートアップスクリプト
metadata = compute_v1.Metadata()
metadata.items = [
    compute_v1.Items(
        key="startup-script",
        value="""#!/bin/bash
            apt-get update
            apt-get install -y nginx
            systemctl start nginx
            systemctl enable nginx
            echo '<h1>Hello from Google Cloud!</h1>' > /var/www/html/index.html
        """
    )
]
instance.metadata = metadata

# タグの設定
instance.tags = compute_v1.Tags(items=["web-server"])

# ラベルの設定
instance.labels = {
    "environment": "production",
    "application": "webapp"
}

# インスタンス作成の実行
operation = instances_client.insert(
    project=project_id,
    zone=zone,
    instance_resource=instance
)

print(f"Creating instance: {instance.name}")

# 作成完了を待機
while operation.status != compute_v1.Operation.Status.DONE:
    time.sleep(1)
    operation = instances_client.get(
        project=project_id,
        zone=zone,
        instance=operation.target_link.split('/')[-1]
    )

print(f"Instance {instance.name} created successfully")

# Google Kubernetes Engine (GKE) クラスター作成
apiVersion: container.googleapis.com/v1
kind: Cluster
metadata:
  name: webapp-cluster
spec:
  location: asia-northeast1
  initialNodeCount: 3
  nodeConfig:
    machineType: e2-medium
    diskSizeGb: 50
    preemptible: false
    oauthScopes:
      - https://www.googleapis.com/auth/cloud-platform
    metadata:
      disable-legacy-endpoints: "true"
    labels:
      environment: production
      application: webapp
  networkPolicy:
    enabled: true
  addonsConfig:
    httpLoadBalancing:
      disabled: false
    horizontalPodAutoscaling:
      disabled: false
    networkPolicyConfig:
      disabled: false
  workloadIdentityConfig:
    workloadPool: my-project-id.svc.id.goog
  releaseChannel:
    channel: REGULAR
  maintenancePolicy:
    window:
      dailyMaintenanceWindow:
        startTime: "03:00"

3. ストレージとデータベースサービス

# Cloud Storage操作
from google.cloud import storage
from google.cloud import firestore
from google.cloud import spanner
import datetime

# Cloud Storage操作
storage_client = storage.Client()

# バケット作成
bucket_name = "my-webapp-bucket"
bucket = storage_client.bucket(bucket_name)
bucket.location = "ASIA-NORTHEAST1"
bucket.storage_class = "STANDARD"

# バケットが存在しない場合は作成
if not bucket.exists():
    bucket = storage_client.create_bucket(bucket_name, location="asia-northeast1")
    print(f"Bucket {bucket_name} created")

# ライフサイクル管理ルールの設定
bucket.lifecycle_management_rules = [
    {
        "action": {"type": "SetStorageClass", "storageClass": "NEARLINE"},
        "condition": {"age": 30}
    },
    {
        "action": {"type": "SetStorageClass", "storageClass": "COLDLINE"},
        "condition": {"age": 365}
    },
    {
        "action": {"type": "Delete"},
        "condition": {"age": 2555}  # 7 years
    }
]
bucket.patch()

# ファイルアップロード
blob = bucket.blob("uploads/sample.txt")
blob.metadata = {
    "author": "user123",
    "purpose": "demo",
    "uploaded_at": datetime.datetime.now().isoformat()
}

with open("local-file.txt", "rb") as file:
    blob.upload_from_file(file, content_type="text/plain")

print(f"File uploaded to {blob.name}")

# Firestore（NoSQLデータベース）操作
firestore_client = firestore.Client()

# コレクションの作成とドキュメント追加
users_ref = firestore_client.collection('users')
user_doc = {
    'name': '田中太郎',
    'email': '[email protected]',
    'status': 'active',
    'created_at': firestore.SERVER_TIMESTAMP,
    'preferences': {
        'theme': 'dark',
        'language': 'ja'
    }
}

doc_ref = users_ref.document('user123')
doc_ref.set(user_doc)

# ドキュメント読み取り
doc = doc_ref.get()
if doc.exists:
    print(f"User data: {doc.to_dict()}")

# クエリの実行
active_users = users_ref.where('status', '==', 'active').stream()
for user in active_users:
    print(f"Active user: {user.id} => {user.to_dict()}")

# Cloud Spanner（分散RDBMSデータベース）操作
from google.cloud.spanner_v1 import param_types

spanner_client = spanner.Client()
instance_id = "webapp-instance"
database_id = "webapp-db"

# Spannerインスタンスの作成（必要に応じて）
instance_config = f"projects/{project_id}/instanceConfigs/regional-asia-northeast1"
instance = spanner_client.instance(instance_id, instance_config)

if not instance.exists():
    operation = instance.create()
    print(f"Creating Spanner instance: {instance_id}")
    operation.result(120)  # 2分でタイムアウト

# データベースの作成
database = instance.database(database_id, ddl_statements=[
    """
    CREATE TABLE Users (
        UserId STRING(36) NOT NULL,
        Name STRING(100),
        Email STRING(255),
        CreatedAt TIMESTAMP,
        Status STRING(20)
    ) PRIMARY KEY (UserId)
    """,
    """
    CREATE INDEX UsersByStatus ON Users(Status)
    """
])

if not database.exists():
    operation = database.create()
    print(f"Creating Spanner database: {database_id}")
    operation.result(120)

# データの挿入
with database.batch() as batch:
    batch.insert(
        table="Users",
        columns=("UserId", "Name", "Email", "CreatedAt", "Status"),
        values=[
            ("user123", "田中太郎", "[email protected]", spanner.COMMIT_TIMESTAMP, "active"),
            ("user456", "佐藤花子", "[email protected]", spanner.COMMIT_TIMESTAMP, "active")
        ]
    )

# データの読み取り
with database.snapshot() as snapshot:
    results = snapshot.execute_sql(
        "SELECT UserId, Name, Email FROM Users WHERE Status = @status",
        params={"status": "active"},
        param_types={"status": param_types.STRING}
    )
    
    for row in results:
        print(f"User: {row[0]} - {row[1]} ({row[2]})")

4. ネットワーキングとセキュリティ

# Cloud IAM とセキュリティ設定
from google.cloud import secretmanager
from google.cloud import iam
from google.oauth2 import service_account

# Secret Manager操作
secrets_client = secretmanager.SecretManagerServiceClient()
project_path = f"projects/{project_id}"

# シークレットの作成
secret_id = "database-password"
secret_path = secrets_client.secret_path(project_id, secret_id)

try:
    secret = secrets_client.create_secret(
        request={
            "parent": project_path,
            "secret_id": secret_id,
            "secret": {
                "replication": {"automatic": {}}
            }
        }
    )
    print(f"Created secret: {secret.name}")
except Exception as e:
    print(f"Secret may already exist: {e}")

# シークレットバージョンの追加
secret_value = "SecurePassword123!"
response = secrets_client.add_secret_version(
    request={
        "parent": secret_path,
        "payload": {"data": secret_value.encode("UTF-8")}
    }
)
print(f"Added secret version: {response.name}")

# シークレットの取得
version_path = secrets_client.secret_version_path(project_id, secret_id, "latest")
response = secrets_client.access_secret_version(request={"name": version_path})
secret_data = response.payload.data.decode("UTF-8")
print(f"Retrieved secret: {secret_data}")

# VPC ネットワーク作成
networks_client = compute_v1.NetworksClient()
subnets_client = compute_v1.SubnetworksClient()

# カスタムVPCネットワーク
network = compute_v1.Network()
network.name = "webapp-vpc"
network.routing_config = compute_v1.NetworkRoutingConfig()
network.routing_config.routing_mode = "REGIONAL"

operation = networks_client.insert(
    project=project_id,
    network_resource=network
)

print(f"Creating VPC network: {network.name}")

# サブネット作成
subnet = compute_v1.Subnetwork()
subnet.name = "webapp-subnet"
subnet.ip_cidr_range = "10.0.1.0/24"
subnet.network = f"projects/{project_id}/global/networks/{network.name}"
subnet.region = region

operation = subnets_client.insert(
    project=project_id,
    region=region,
    subnetwork_resource=subnet
)

print(f"Creating subnet: {subnet.name}")

# ファイアウォールルール（詳細設定）
firewall_rules = [
    {
        "name": "allow-internal",
        "direction": "INGRESS",
        "allowed": [{"IPProtocol": "tcp"}, {"IPProtocol": "udp"}, {"IPProtocol": "icmp"}],
        "source_ranges": ["10.0.0.0/8"],
        "target_tags": ["internal"]
    },
    {
        "name": "allow-ssh",
        "direction": "INGRESS",
        "allowed": [{"IPProtocol": "tcp", "ports": ["22"]}],
        "source_ranges": ["0.0.0.0/0"],
        "target_tags": ["ssh-allowed"]
    },
    {
        "name": "allow-web-traffic",
        "direction": "INGRESS",
        "allowed": [{"IPProtocol": "tcp", "ports": ["80", "443"]}],
        "source_ranges": ["0.0.0.0/0"],
        "target_tags": ["web-server"]
    }
]

for rule_config in firewall_rules:
    firewall_rule = compute_v1.Firewall()
    firewall_rule.name = rule_config["name"]
    firewall_rule.direction = rule_config["direction"]
    firewall_rule.allowed = [
        compute_v1.Allowed(**allowed) for allowed in rule_config["allowed"]
    ]
    firewall_rule.source_ranges = rule_config["source_ranges"]
    firewall_rule.target_tags = rule_config["target_tags"]
    firewall_rule.network = f"projects/{project_id}/global/networks/{network.name}"
    
    operation = firewalls_client.insert(
        project=project_id,
        firewall_resource=firewall_rule
    )
    print(f"Creating firewall rule: {firewall_rule.name}")

5. サーバーレスとFunctions

# Cloud Functions (Python)
import functions_framework
from google.cloud import firestore
from google.cloud import pubsub_v1
import json
import logging

@functions_framework.http
def process_user_request(request):
    """HTTPトリガーのCloud Function"""
    
    # CORSヘッダーの設定
    if request.method == 'OPTIONS':
        headers = {
            'Access-Control-Allow-Origin': '*',
            'Access-Control-Allow-Methods': 'GET, POST',
            'Access-Control-Allow-Headers': 'Content-Type',
            'Access-Control-Max-Age': '3600'
        }
        return ('', 204, headers)
    
    headers = {'Access-Control-Allow-Origin': '*'}
    
    try:
        # リクエストデータの取得
        request_json = request.get_json()
        if not request_json:
            return ({'error': 'No JSON body provided'}, 400, headers)
        
        # Firestore クライアントの初期化
        firestore_client = firestore.Client()
        
        if request.method == 'POST':
            # ユーザー作成
            user_data = {
                'name': request_json.get('name'),
                'email': request_json.get('email'),
                'status': 'active',
                'created_at': firestore.SERVER_TIMESTAMP
            }
            
            doc_ref = firestore_client.collection('users').document()
            doc_ref.set(user_data)
            
            # Pub/Sub にメッセージ送信
            publisher = pubsub_v1.PublisherClient()
            topic_path = publisher.topic_path('my-project-id', 'user-events')
            
            message_data = {
                'event_type': 'user_created',
                'user_id': doc_ref.id,
                'user_data': user_data
            }
            
            publisher.publish(
                topic_path,
                json.dumps(message_data, default=str).encode('utf-8')
            )
            
            return ({'message': 'User created', 'user_id': doc_ref.id}, 201, headers)
            
        elif request.method == 'GET':
            # ユーザー一覧取得
            users_ref = firestore_client.collection('users')
            users = [doc.to_dict() for doc in users_ref.stream()]
            
            return ({'users': users, 'count': len(users)}, 200, headers)
    
    except Exception as e:
        logging.error(f"Error processing request: {str(e)}")
        return ({'error': str(e)}, 500, headers)

@functions_framework.cloud_event
def process_pubsub_message(cloud_event):
    """Pub/SubトリガーのCloud Function"""
    
    import base64
    
    # Pub/Subメッセージのデコード
    message_data = base64.b64decode(cloud_event.data['message']['data']).decode('utf-8')
    message_json = json.loads(message_data)
    
    logging.info(f"Processing message: {message_json}")
    
    # メッセージタイプに応じた処理
    event_type = message_json.get('event_type')
    
    if event_type == 'user_created':
        # ユーザー作成時の処理
        user_id = message_json['user_id']
        user_data = message_json['user_data']
        
        # 例：ウェルカムメール送信、ユーザー統計更新など
        logging.info(f"Welcome new user: {user_data['name']} ({user_id})")
        
        # BigQueryへデータ挿入
        from google.cloud import bigquery
        
        bigquery_client = bigquery.Client()
        table_id = "my-project-id.analytics.user_events"
        
        rows_to_insert = [
            {
                "event_timestamp": firestore.SERVER_TIMESTAMP,
                "event_type": event_type,
                "user_id": user_id,
                "user_name": user_data['name'],
                "user_email": user_data['email']
            }
        ]
        
        errors = bigquery_client.insert_rows_json(table_id, rows_to_insert)
        if not errors:
            logging.info("Event logged to BigQuery successfully")
        else:
            logging.error(f"BigQuery insert errors: {errors}")

# Cloud Run サービス（FastAPI）
from fastapi import FastAPI, HTTPException
from google.cloud import firestore
from typing import List, Optional
import uvicorn

app = FastAPI(title="WebApp API", version="1.0.0")

# Firestore クライアント
firestore_client = firestore.Client()

@app.get("/")
async def root():
    return {"message": "Hello from Cloud Run!", "service": "webapp-api"}

@app.get("/health")
async def health_check():
    return {"status": "healthy", "service": "webapp-api"}

@app.get("/users")
async def get_users():
    try:
        users_ref = firestore_client.collection('users')
        users = []
        for doc in users_ref.stream():
            user_data = doc.to_dict()
            user_data['id'] = doc.id
            users.append(user_data)
        return {"users": users, "count": len(users)}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.post("/users")
async def create_user(user_data: dict):
    try:
        doc_ref = firestore_client.collection('users').document()
        user_data['created_at'] = firestore.SERVER_TIMESTAMP
        user_data['status'] = 'active'
        doc_ref.set(user_data)
        
        return {"message": "User created", "user_id": doc_ref.id}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8080)

6. 監視とDevOps統合

# Cloud Monitoring とLogging設定
from google.cloud import monitoring_v3
from google.cloud import logging
import time

# Cloud Monitoring クライアント
monitoring_client = monitoring_v3.MetricServiceClient()
alert_client = monitoring_v3.AlertPolicyServiceClient()
project_name = f"projects/{project_id}"

# カスタムメトリクスの作成
descriptor = monitoring_v3.MetricDescriptor()
descriptor.type = "custom.googleapis.com/webapp/user_registrations"
descriptor.metric_kind = monitoring_v3.MetricDescriptor.MetricKind.GAUGE
descriptor.value_type = monitoring_v3.MetricDescriptor.ValueType.INT64
descriptor.description = "Number of user registrations"

descriptor = monitoring_client.create_metric_descriptor(
    name=project_name,
    metric_descriptor=descriptor
)

# メトリクスデータポイントの送信
series = monitoring_v3.TimeSeries()
series.metric.type = "custom.googleapis.com/webapp/user_registrations"
series.resource.type = "gce_instance"
series.resource.labels["instance_id"] = "your-instance-id"
series.resource.labels["zone"] = "asia-northeast1-a"

now = time.time()
seconds = int(now)
nanos = int((now - seconds) * 10 ** 9)
interval = monitoring_v3.TimeInterval(
    {"end_time": {"seconds": seconds, "nanos": nanos}}
)

point = monitoring_v3.Point(
    {"interval": interval, "value": {"int64_value": 10}}
)
series.points = [point]

monitoring_client.create_time_series(
    name=project_name,
    time_series=[series]
)

# アラートポリシーの作成
alert_policy = monitoring_v3.AlertPolicy(
    display_name="High CPU Usage Alert",
    documentation=monitoring_v3.AlertPolicy.Documentation(
        content="Alert when CPU usage exceeds 80%"
    ),
    conditions=[
        monitoring_v3.AlertPolicy.Condition(
            display_name="CPU usage condition",
            condition_threshold=monitoring_v3.AlertPolicy.Condition.MetricThreshold(
                filter='resource.type="gce_instance"',
                comparison=monitoring_v3.ComparisonType.COMPARISON_GREATER_THAN,
                threshold_value=0.8,
                duration={"seconds": 300},
                aggregations=[
                    monitoring_v3.Aggregation(
                        alignment_period={"seconds": 60},
                        per_series_aligner=monitoring_v3.Aggregation.Aligner.ALIGN_MEAN,
                    )
                ],
            ),
        )
    ],
    enabled=True,
)

alert_policy = alert_client.create_alert_policy(
    name=project_name,
    alert_policy=alert_policy
)

print(f"Created alert policy: {alert_policy.name}")

# Cloud Logging 設定
logging_client = logging.Client()
logging_client.setup_logging()

# ログの送信
logger = logging_client.logger("webapp-api")
logger.log_struct(
    {
        "message": "User registration completed",
        "user_id": "user123",
        "timestamp": time.time(),
        "severity": "INFO"
    }
)

# Cloud Build CI/CD パイプライン (cloudbuild.yaml)
steps:
  # ソースコードのビルド
  - name: 'gcr.io/cloud-builders/docker'
    args: 
      - 'build'
      - '-t'
      - 'gcr.io/$PROJECT_ID/webapp:$BUILD_ID'
      - '-t'
      - 'gcr.io/$PROJECT_ID/webapp:latest'
      - '.'

  # イメージのプッシュ
  - name: 'gcr.io/cloud-builders/docker'
    args: 
      - 'push'
      - 'gcr.io/$PROJECT_ID/webapp:$BUILD_ID'

  - name: 'gcr.io/cloud-builders/docker'
    args: 
      - 'push'
      - 'gcr.io/$PROJECT_ID/webapp:latest'

  # テストの実行
  - name: 'gcr.io/cloud-builders/docker'
    args:
      - 'run'
      - '--rm'
      - 'gcr.io/$PROJECT_ID/webapp:$BUILD_ID'
      - 'npm'
      - 'test'

  # Cloud Run にデプロイ
  - name: 'gcr.io/cloud-builders/gcloud'
    args:
      - 'run'
      - 'deploy'
      - 'webapp-service'
      - '--image'
      - 'gcr.io/$PROJECT_ID/webapp:$BUILD_ID'
      - '--region'
      - 'asia-northeast1'
      - '--platform'
      - 'managed'
      - '--allow-unauthenticated'
      - '--memory'
      - '512Mi'
      - '--cpu'
      - '1'
      - '--concurrency'
      - '100'
      - '--max-instances'
      - '10'
      - '--set-env-vars'
      - 'PROJECT_ID=$PROJECT_ID,ENVIRONMENT=production'

  # デプロイ後のヘルスチェック
  - name: 'gcr.io/cloud-builders/curl'
    args:
      - '-f'
      - 'https://webapp-service-asia-northeast1.run.app/health'

  # BigQuery に デプロイ ログを記録
  - name: 'gcr.io/cloud-builders/gcloud'
    entrypoint: 'bash'
    args:
      - '-c'
      - |
        bq query --use_legacy_sql=false \
        "INSERT INTO \`$PROJECT_ID.analytics.deployment_logs\` \
        (deployment_id, build_id, service_name, image_tag, deployed_at, status) \
        VALUES ('$BUILD_ID', '$BUILD_ID', 'webapp-service', 'gcr.io/$PROJECT_ID/webapp:$BUILD_ID', CURRENT_TIMESTAMP(), 'SUCCESS')"

# ビルドトリガー設定
options:
  logging: CLOUD_LOGGING_ONLY
  machineType: 'E2_HIGHCPU_8'

timeout: '1200s'

# 成果物の保存
images:
  - 'gcr.io/$PROJECT_ID/webapp:$BUILD_ID'
  - 'gcr.io/$PROJECT_ID/webapp:latest'

# 環境変数
substitutions:
  _DEPLOY_REGION: 'asia-northeast1'
  _SERVICE_NAME: 'webapp-service'

Google Cloud Platformは、データ分析・機械学習に特化した革新的なサービスと、Googleの世界規模のインフラストラクチャにより、データドリブンなアプリケーション開発を強力にサポートします。