高级 GCP 云工程师面试问题

介绍

高级 GCP 云工程师面试通常考察你能否解释生产环境中的取舍，而不只是记住 Google Cloud 服务名称。你需要能针对具体负载说明为什么选择 GKE、Cloud Run、Cloud SQL、Spanner、Shared VPC、IAM 控制和成本护栏。

用这些问题练习高级岗位需要的回答方式：先说明需求，再解释设计选择，指出风险，并说明如何在生产环境中运营它。

架构与设计

1. 在 GCP 上设计一个高可用性的应用程序。

回答： 具有冗余和可扩展性的生产就绪架构：

Loading diagram...

关键组件：

# 创建具有自动缩放功能的托管实例组
gcloud compute instance-groups managed create my-mig \
  --base-instance-name=my-app \
  --template=my-template \
  --size=3 \
  --zone=us-central1-a

# 配置自动缩放
gcloud compute instance-groups managed set-autoscaling my-mig \
  --max-num-replicas=10 \
  --min-num-replicas=3 \
  --target-cpu-utilization=0.7 \
  --cool-down-period=90

# 创建负载均衡器
gcloud compute backend-services create my-backend \
  --protocol=HTTP \
  --health-checks=my-health-check \
  --global

# 将实例组添加到后端
gcloud compute backend-services add-backend my-backend \
  --instance-group=my-mig \
  --instance-group-zone=us-central1-a \
  --global

设计原则：

多可用区部署
基于指标的自动缩放
用于数据库的托管服务
用于静态内容的 CDN
健康检查和监控

稀有度： 非常常见 难度： 困难

Google Kubernetes Engine (GKE)

2. 如何在 GKE 上部署和管理应用程序？

回答： GKE 是 Google 的托管 Kubernetes 服务。

部署过程：

# 创建 GKE 集群
gcloud container clusters create my-cluster \
  --num-nodes=3 \
  --machine-type=e2-medium \
  --zone=us-central1-a \
  --enable-autoscaling \
  --min-nodes=3 \
  --max-nodes=10

# 获取凭据
gcloud container clusters get-credentials my-cluster \
  --zone=us-central1-a

# 部署应用程序
kubectl apply -f - <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: gcr.io/my-project/myapp:v1
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
          limits:
            cpu: 500m
            memory: 512Mi
---
apiVersion: v1
kind: Service
metadata:
  name: myapp-service
spec:
  type: LoadBalancer
  selector:
    app: myapp
  ports:
  - port: 80
    targetPort: 8080
EOF

值得提到的 GKE 功能：

使用区域集群提高控制平面和节点可用性
Cluster autoscaling 与 Horizontal Pod Autoscaling
使用 Workload Identity Federation for GKE，而不是长期服务账号密钥
Binary Authorization 和镜像扫描用于供应链控制
Cloud Logging、Cloud Monitoring、SLO 和告警

稀有度： 非常常见 难度： 困难

Serverless 和高级服务

3. 何时使用 Cloud Functions 与 Cloud Run？

回答： 根据你需要承担的运维责任来选择。好的回答会比较触发方式、打包方式、运行时控制、扩缩容行为和运维复杂度。

Cloud Functions：

适合 Pub/Sub、Cloud Storage、Eventarc 或简单 HTTP 的小型事件处理器
基础设施暴露面最小
适合团队希望按函数部署且不需要自定义容器的场景
相比容器服务，对运行时形态的控制更少

Cloud Run：

适合容器化 HTTP 服务、API、worker 和事件驱动服务
对依赖、并发、CPU 分配、启动行为和流量拆分有更多控制
可缩容到零，也可为低延迟路径配置最小实例
当需要可移植性、自定义运行时或服务级责任时，通常是更好的默认选择

# Cloud Function 示例
def hello_pubsub(event, context):
    """由 Pub/Sub 消息触发"""
    import base64
    
    if 'data' in event:
        message = base64.b64decode(event['data']).decode('utf-8')
        print(f'Received message: {message}')
        
        # 处理消息
        process_data(message)

# 部署 Cloud Function
gcloud functions deploy hello_pubsub \
  --runtime=python312 \
  --trigger-topic=my-topic \
  --entry-point=hello_pubsub

# 部署 Cloud Run
gcloud run deploy myapp \
  --image=gcr.io/my-project/myapp:v1 \
  --region=us-central1 \
  --allow-unauthenticated

稀有度： 常见 难度： 中等

高级网络

4. 解释 Shared VPC 以及何时使用它。

回答： Shared VPC 允许多个项目共享一个通用的 VPC 网络。

优点：

集中式网络管理
跨项目资源共享
简化计费
一致的安全策略

架构：

Loading diagram...

# 在宿主项目中启用 Shared VPC
gcloud compute shared-vpc enable my-host-project

# 附加服务项目
gcloud compute shared-vpc associated-projects add my-service-project \
  --host-project=my-host-project

# 授予权限
gcloud projects add-iam-policy-binding my-host-project \
  --member=serviceAccount:[email protected] \
  --role=roles/compute.networkUser

使用案例：

大型组织
多团队环境
集中式网络管理
合规性要求

稀有度： 常见 难度： 中等偏难

成本优化

5. 如何优化 GCP 成本？

回答： 成本优化策略：

1. 调整实例大小：

# 使用 Recommender API
gcloud recommender recommendations list \
  --project=my-project \
  --location=us-central1 \
  --recommender=google.compute.instance.MachineTypeRecommender

2. 承诺使用折扣：

对可预测负载使用 1 年或 3 年承诺
对支出模式使用灵活承诺；对明确的计算资源使用基于资源的承诺
与合理规格调整配合，避免把浪费固定下来

3. Spot VM：

# 为可中断任务创建 Spot VM
gcloud compute instances create my-spot-vm \
  --provisioning-model=SPOT \
  --machine-type=e2-medium

4. 存储生命周期：

# 设置生命周期策略
gsutil lifecycle set lifecycle.json gs://my-bucket

# lifecycle.json
{
  "lifecycle": {
    "rule": [
      {
        "action": {"type": "SetStorageClass", "storageClass": "NEARLINE"},
        "condition": {"age": 30}
      },
      {
        "action": {"type": "Delete"},
        "condition": {"age": 365}
      }
    ]
  }
}

5. 监控：

Cloud Billing 报告
预算提醒
按服务/项目细分的成本

稀有度： 非常常见 难度： 中等

安全

6. 如何在 GCP 中实施安全最佳实践？

回答： 采用分层模型：先设计身份，再在能减少暴露面的地方使用私有网络，对敏感数据加密，并通过日志和 Security Command Center 持续检测。

1. IAM 最佳实践：

# 使用具有最小权限的服务账号
gcloud iam service-accounts create my-app-sa \
  --display-name="My App Service Account"

# 授予特定角色
gcloud projects add-iam-policy-binding my-project \
  --member=serviceAccount:[email protected] \
  --role=roles/storage.objectViewer \
  --condition='expression=resource.name.startsWith("projects/_/buckets/my-bucket"),title=bucket-access'

面试中可以说明：生产环境避免使用基础角色，区分人员身份和工作负载身份，优先使用短期凭据和 Workload Identity Federation，并定期审查 IAM 绑定。

2. VPC 安全：

Private Google Access (私有 Google 访问通道)
VPC Service Controls (VPC 服务控制)
Cloud Armor 用于 DDoS 防护

3. 数据加密：

# 客户管理的加密密钥
gcloud kms keyrings create my-keyring \
  --location=global

gcloud kms keys create my-key \
  --location=global \
  --keyring=my-keyring \
  --purpose=encryption

# 与 Cloud Storage 一起使用
gsutil -o 'GSUtil:encryption_key=...' cp file.txt gs://my-bucket/

4. 监控：

Cloud Audit Logs (云审计日志)
Security Command Center (安全指挥中心)
Cloud Logging and Monitoring (云日志记录和监控)

稀有度： 非常常见 难度： 困难

数据分析

7. 如何设计和优化 BigQuery 以进行大规模分析？

回答： BigQuery 是 Google 的无服务器、高度可扩展的数据仓库。

架构：

列式存储
自动缩放
SQL 接口
PB 级
按查询付费

表设计：

-- 创建分区表
CREATE TABLE mydataset.events
(
  event_id STRING,
  user_id STRING,
  event_type STRING,
  event_data JSON,
  event_timestamp TIMESTAMP
)
PARTITION BY DATE(event_timestamp)
CLUSTER BY user_id, event_type
OPTIONS(
  partition_expiration_days=90,
  require_partition_filter=true
);

-- 创建物化视图
CREATE MATERIALIZED VIEW mydataset.daily_summary
AS
SELECT
  DATE(event_timestamp) as event_date,
  event_type,
  COUNT(*) as event_count,
  COUNT(DISTINCT user_id) as unique_users
FROM mydataset.events
GROUP BY event_date, event_type;

优化策略：

1. 分区：

-- 基于时间的分区
CREATE TABLE mydataset.sales
PARTITION BY DATE(sale_date)
AS SELECT * FROM source_table;

-- 整数范围分区
CREATE TABLE mydataset.user_data
PARTITION BY RANGE_BUCKET(user_id, GENERATE_ARRAY(0, 1000000, 10000))
AS SELECT * FROM source_table;

-- 使用分区过滤器进行查询（具有成本效益）
SELECT *
FROM mydataset.events
WHERE DATE(event_timestamp) BETWEEN '2024-01-01' AND '2024-01-31'
  AND event_type = 'purchase';

2. 聚簇：

-- 按经常过滤的列进行聚簇
CREATE TABLE mydataset.logs
PARTITION BY DATE(log_timestamp)
CLUSTER BY user_id, region, status
AS SELECT * FROM source_logs;

-- 查询受益于聚簇
SELECT *
FROM mydataset.logs
WHERE DATE(log_timestamp) = '2024-11-26'
  AND user_id = '12345'
  AND region = 'us-east1';

3. 查询优化：

-- 坏：SELECT * （扫描所有列）
SELECT * FROM mydataset.large_table;

-- 好：SELECT 特定列
SELECT user_id, event_type, event_timestamp
FROM mydataset.large_table;

-- 对大型数据集使用近似聚合
SELECT APPROX_COUNT_DISTINCT(user_id) as unique_users
FROM mydataset.events;

-- 避免自连接，使用窗口函数
SELECT
  user_id,
  event_timestamp,
  LAG(event_timestamp) OVER (PARTITION BY user_id ORDER BY event_timestamp) as prev_event
FROM mydataset.events;

4. 成本控制：

# 设置最大计费字节数
bq query \
  --maximum_bytes_billed=1000000000 \
  --use_legacy_sql=false \
  'SELECT COUNT(*) FROM mydataset.large_table'

# 试运行以估算成本
bq query \
  --dry_run \
  --use_legacy_sql=false \
  'SELECT * FROM mydataset.large_table'

数据加载：

# 从 Cloud Storage 加载
bq load \
  --source_format=NEWLINE_DELIMITED_JSON \
  --autodetect \
  mydataset.mytable \
  gs://mybucket/data/*.json

# 使用架构加载
bq load \
  --source_format=CSV \
  --skip_leading_rows=1 \
  mydataset.mytable \
  gs://mybucket/data.csv \
  schema.json

# 流式插入（实时）
from google.cloud import bigquery

client = bigquery.Client()
table_id = "my-project.mydataset.mytable"

rows_to_insert = [
    {"user_id": "123", "event_type": "click", "timestamp": "2024-11-26T10:00:00"},
    {"user_id": "456", "event_type": "purchase", "timestamp": "2024-11-26T10:05:00"},
]

errors = client.insert_rows_json(table_id, rows_to_insert)
if errors:
    print(f"Errors: {errors}")

最佳实践：

始终使用分区过滤器
按高基数列进行聚簇
避免 SELECT *
对大型数据集使用近似函数
监控查询成本
对重复查询使用物化视图
在适当的时候反规范化数据

稀有度： 非常常见 难度： 困难

高级数据库服务

8. 何时使用 Cloud Spanner 与 Cloud SQL？

回答： 根据规模、一致性和地域要求进行选择：

Cloud Spanner：

全球分布式关系数据库
水平扩展（无限）
跨区域的强一致性
99.999% 的可用性 SLA
更高的成本

Cloud SQL：

区域性托管数据库（MySQL、PostgreSQL、SQL Server）
垂直扩展（有限）
单区域（带有只读副本）
99.95% 的可用性 SLA
更低的成本

比较：

特性	Cloud Spanner	Cloud SQL
规模	PB 级	TB 级
一致性	全局强一致性	区域性
可用性	99.999%	99.95%
延迟	全球个位数毫秒级	低（区域性）
成本	高	中等
使用案例	全球应用，金融系统	区域应用，传统工作负载

Cloud Spanner 示例：

-- 创建 Spanner 实例
gcloud spanner instances create my-instance \
  --config=regional-us-central1 \
  --nodes=3 \
  --description="Production instance"

-- 创建数据库
gcloud spanner databases create my-database \
  --instance=my-instance \
  --ddl='CREATE TABLE Users (
    UserId INT64 NOT NULL,
    Username STRING(100),
    Email STRING(255),
    CreatedAt TIMESTAMP
  ) PRIMARY KEY (UserId)'

-- 插入数据
gcloud spanner databases execute-sql my-database \
  --instance=my-instance \
  --sql="INSERT INTO Users (UserId, Username, Email, CreatedAt)
        VALUES (1, 'alice', '[email protected]', CURRENT_TIMESTAMP())"

-- 使用强一致性进行查询
gcloud spanner databases execute-sql my-database \
  --instance=my-instance \
  --sql="SELECT * FROM Users WHERE UserId = 1"

Python 客户端：

from google.cloud import spanner

# 创建客户端
spanner_client = spanner.Client()
instance = spanner_client.instance('my-instance')
database = instance.database('my-database')

# 使用强一致性读取
def read_user(user_id):
    with database.snapshot() as snapshot:
        results = snapshot.execute_sql(
            "SELECT UserId, Username, Email FROM Users WHERE UserId = @user_id",
            params={"user_id": user_id},
            param_types={"user_id": spanner.param_types.INT64}
        )
        for row in results:
            print(f"User: {row[0]}, {row[1]}, {row[2]}")

# 使用事务写入
def create_user(user_id, username, email):
    def insert_user(transaction):
        transaction.execute_update(
            "INSERT INTO Users (UserId, Username, Email, CreatedAt) "
            "VALUES (@user_id, @username, @email, CURRENT_TIMESTAMP())",
            params={
                "user_id": user_id,
                "username": username,
                "email": email
            },
            param_types={
                "user_id": spanner.param_types.INT64,
                "username": spanner.param_types.STRING,
                "email": spanner.param_types.STRING
            }
        )
    
    database.run_in_transaction(insert_user)

Cloud SQL 示例：

# 创建 Cloud SQL 实例
gcloud sql instances create my-instance \
  --database-version=POSTGRES_14 \
  --tier=db-n1-standard-2 \
  --region=us-central1 \
  --root-password=mypassword

# 创建数据库
gcloud sql databases create mydatabase \
  --instance=my-instance

# 连接
gcloud sql connect my-instance --user=postgres

# 创建只读副本
gcloud sql instances create my-replica \
  --master-instance-name=my-instance \
  --tier=db-n1-standard-1 \
  --region=us-east1

何时使用：

在以下情况下使用 Cloud Spanner：

需要全球分布
需要跨区域的强一致性
规模超出单个区域
金融交易
任务关键型应用程序
预算允许更高的成本

在以下情况下使用 Cloud SQL：

区域性应用程序
熟悉 MySQL/PostgreSQL
对成本敏感
中等规模（< 10TB）
现有的 SQL 工作负载
不需要全局一致性

稀有度： 常见 难度： 中等偏难

安全与合规

9. 如何实施 VPC Service Controls？

回答： VPC Service Controls 在 GCP 资源周围创建安全边界，以防止数据泄露。

关键概念：

服务边界： 资源周围的边界
访问级别： 访问条件
入口/出口规则： 控制数据流

架构：

Loading diagram...

设置：

# 创建访问策略
gcloud access-context-manager policies create \
  --organization=123456789 \
  --title="Production Policy"

# 创建访问级别
gcloud access-context-manager levels create CorpNetwork \
  --policy=accessPolicies/123456789 \
  --title="Corporate Network" \
  --basic-level-spec=access_level.yaml

# access_level.yaml
conditions:
  - ipSubnetworks:
    - 203.0.113.0/24  # 公司 IP 范围
  - members:
    - user:[email protected]

创建服务边界：

# 创建边界
gcloud access-context-manager perimeters create production_perimeter \
  --policy=accessPolicies/123456789 \
  --title="Production Perimeter" \
  --resources=projects/123456789012 \
  --restricted-services=storage.googleapis.com,bigquery.googleapis.com \
  --access-levels=accessPolicies/123456789/accessLevels/CorpNetwork

# 将项目添加到边界
gcloud access-context-manager perimeters update production_perimeter \
  --policy=accessPolicies/123456789 \
  --add-resources=projects/987654321098

入口/出口规则：

# ingress_rule.yaml
ingressPolicies:
  - ingressFrom:
      sources:
        - accessLevel: accessPolicies/123456789/accessLevels/CorpNetwork
      identities:
        - serviceAccount:[email protected]
    ingressTo:
      resources:
        - '*'
      operations:
        - serviceName: storage.googleapis.com
          methodSelectors:
            - method: '*'

# 应用入口规则
gcloud access-context-manager perimeters update production_perimeter \
  --policy=accessPolicies/123456789 \
  --set-ingress-policies=ingress_rule.yaml

出口规则：

# egress_rule.yaml
egressPolicies:
  - egressFrom:
      identities:
        - serviceAccount:[email protected]
    egressTo:
      resources:
        - projects/external-project-id
      operations:
        - serviceName: storage.googleapis.com
          methodSelectors:
            - method: 'google.storage.objects.create'

# 应用出口规则
gcloud access-context-manager perimeters update production_perimeter \
  --policy=accessPolicies/123456789 \
  --set-egress-policies=egress_rule.yaml

支持的服务：

Cloud Storage
BigQuery
Cloud SQL
Compute Engine
GKE
Cloud Functions
以及更多

测试：

# 测试从边界内的访问
from google.cloud import storage

def test_access():
    try:
        client = storage.Client()
        bucket = client.bucket('my-protected-bucket')
        blobs = list(bucket.list_blobs())
        print(f"Access granted: {len(blobs)} objects")
    except Exception as e:
        print(f"Access denied: {e}")

# 这将从授权网络成功
# 这将从未经授权的网络失败
test_access()

监控：

# 查看 VPC SC 日志
gcloud logging read \
  'protoPayload.metadata.@type="type.googleapis.com/google.cloud.audit.VpcServiceControlAuditMetadata"' \
  --limit=50 \
  --format=json

使用案例：

防止数据泄露
合规性要求（HIPAA、PCI-DSS）
保护敏感数据
隔离生产环境
多租户安全

最佳实践：

从试运行模式开始
在强制执行之前进行彻底测试
使用访问级别进行细粒度控制
监控 VPC SC 日志
记录边界边界
定期访问审查

稀有度： 不常见 难度： 困难

结论

高级 GCP 云工程师面试需要深入的技术知识和实践经验。重点关注：

架构： 高可用性、可扩展性、灾难恢复
GKE： 容器编排、部署策略
Serverless： Cloud Functions、Cloud Run 使用案例
网络： Shared VPC、混合连接
成本优化： 调整实例大小、承诺使用、生命周期策略
安全： IAM、加密、VPC 控制

尽量把回答连接到你处理过的事故、迁移、成本审查或可靠性改进。这样比单纯列服务更有说服力。

最新职业建议

高级 GCP 云工程师面试问题与答案

介绍

架构与设计

1. 在 GCP 上设计一个高可用性的应用程序。

Google Kubernetes Engine (GKE)

2. 如何在 GKE 上部署和管理应用程序？

Serverless 和高级服务

3. 何时使用 Cloud Functions 与 Cloud Run？

高级网络

4. 解释 Shared VPC 以及何时使用它。

成本优化

5. 如何优化 GCP 成本？

安全

6. 如何在 GCP 中实施安全最佳实践？

数据分析

7. 如何设计和优化 BigQuery 以进行大规模分析？

高级数据库服务

8. 何时使用 Cloud Spanner 与 Cloud SQL？

安全与合规

9. 如何实施 VPC Service Controls？

结论

真正有效的每周职业建议

真正有效的每周职业建议

相关文章

Node.js 高级后端面试题

Python 高级后端开发面试题

Go后端开发工程师面试题：实用指南

停止申请，开始被录用

分享这篇文章

战胜75%的ATS拒绝率