Perguntas entrevista Senior GCP Cloud Engineer

Introdução

Entrevistas para Senior GCP Cloud Engineer normalmente testam se você sabe justificar decisões de produção, não apenas citar serviços do Google Cloud. Prepare-se para explicar quando escolher GKE, Cloud Run, Cloud SQL, Spanner, VPC Compartilhada, controles de IAM e guardrails de custo para uma carga específica.

Use estas perguntas para praticar respostas de nível sênior: comece pelo requisito, justifique a escolha, aponte riscos e explique como operaria a solução em produção.

Arquitetura & Design

1. Desenhe uma aplicação de alta disponibilidade no GCP.

Resposta: Arquitetura pronta para produção com redundância e escalabilidade:

Loading diagram...

Componentes Chave:

# Criar grupo de instâncias gerenciadas com autoescalabilidade
gcloud compute instance-groups managed create my-mig \
  --base-instance-name=my-app \
  --template=my-template \
  --size=3 \
  --zone=us-central1-a

# Configurar autoescalabilidade
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

# Criar balanceador de carga
gcloud compute backend-services create my-backend \
  --protocol=HTTP \
  --health-checks=my-health-check \
  --global

# Adicionar grupo de instâncias ao backend
gcloud compute backend-services add-backend my-backend \
  --instance-group=my-mig \
  --instance-group-zone=us-central1-a \
  --global

Princípios de Design:

Implantação multi-zona
Autoescalabilidade baseada em métricas
Serviços gerenciados para bancos de dados
CDN para conteúdo estático
Verificações de saúde e monitoramento

Raridade: Muito Comum Dificuldade: Difícil

Google Kubernetes Engine (GKE)

2. Como você implanta e gerencia aplicações no GKE?

Resposta: GKE é o serviço Kubernetes gerenciado do Google.

Processo de Implantação:

# Criar cluster 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

# Obter credenciais
gcloud container clusters get-credentials my-cluster \
  --zone=us-central1-a

# Implantar aplicação
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

Recursos do GKE que vale mencionar:

Clusters regionais para disponibilidade do control plane e dos nós
Cluster autoscaling com Horizontal Pod Autoscaling
Workload Identity Federation for GKE em vez de chaves longas de conta de serviço
Binary Authorization e varredura de imagens para controle da cadeia de suprimentos
Cloud Logging, Cloud Monitoring, SLOs e alertas

Raridade: Muito Comum Dificuldade: Difícil

Serverless & Serviços Avançados

3. Quando você usaria Cloud Functions vs Cloud Run?

Resposta: Escolha com base no contrato operacional que você precisa assumir. Uma boa resposta compara gatilhos, empacotamento, controle do runtime, escalabilidade e complexidade operacional.

Cloud Functions:

Melhor para pequenos handlers de eventos de Pub/Sub, Cloud Storage, Eventarc ou HTTP simples
Superfície mínima de infraestrutura
Útil quando o time quer deploy por função e não precisa de contêiner personalizado
Menos controle sobre o runtime do que em um serviço conteinerizado

Cloud Run:

Melhor para serviços HTTP, APIs, workers e serviços orientados a eventos em contêineres
Mais controle sobre dependências, concorrência, CPU, inicialização e divisão de tráfego
Escala para zero, mas pode usar instâncias mínimas para rotas sensíveis à latência
Geralmente é a melhor opção quando você precisa de portabilidade, runtime próprio ou responsabilidade no nível do serviço

# Exemplo de Cloud Function
def hello_pubsub(event, context):
    """Acionado por mensagem Pub/Sub"""
    import base64
    
    if 'data' in event:
        message = base64.b64decode(event['data']).decode('utf-8')
        print(f'Mensagem recebida: {message}')
        
        # Processar mensagem
        process_data(message)

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

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

Raridade: Comum Dificuldade: Média

Rede Avançada

4. Explique VPC Compartilhado e quando usá-lo.

Resposta: VPC Compartilhado permite que múltiplos projetos compartilhem uma rede VPC comum.

Benefícios:

Administração de rede centralizada
Compartilhamento de recursos entre projetos
Faturamento simplificado
Políticas de segurança consistentes

Arquitetura:

Loading diagram...

# Habilitar VPC Compartilhado no projeto host
gcloud compute shared-vpc enable my-host-project

# Anexar projeto de serviço
gcloud compute shared-vpc associated-projects add my-service-project \
  --host-project=my-host-project

# Conceder permissões
gcloud projects add-iam-policy-binding my-host-project \
  --member=serviceAccount:[email protected] \
  --role=roles/compute.networkUser

Casos de Uso:

Grandes organizações
Ambientes multi-time
Gerenciamento de rede centralizado
Requisitos de conformidade

Raridade: Comum Dificuldade: Média-Difícil

Otimização de Custos

5. Como você otimiza os custos do GCP?

Resposta: Estratégias de otimização de custos:

1. Dimensionamento adequado (Right-sizing):

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

2. Descontos por Uso Contínuo (Committed Use Discounts):

Compromissos de 1 ou 3 anos para cargas previsíveis
Compromissos flexíveis para padrões de gasto; compromissos baseados em recursos para uso específico de compute
Combine com dimensionamento adequado para não travar desperdício

3. Spot VMs:

# Criar Spot VM para trabalho interrompível
gcloud compute instances create my-spot-vm \
  --provisioning-model=SPOT \
  --machine-type=e2-medium

4. Ciclo de Vida do Armazenamento (Storage Lifecycle):

# Definir política de ciclo de vida
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. Monitoramento:

Relatórios do Cloud Billing
Alertas de orçamento
Detalhamento de custos por serviço/projeto

Raridade: Muito Comum Dificuldade: Média

Segurança

6. Como você implementa as melhores práticas de segurança no GCP?

Resposta: Use um modelo em camadas: identidade primeiro, rede privada quando reduz exposição, criptografia para dados sensíveis e detecção contínua com logs e Security Command Center.

1. Melhores Práticas de IAM:

# Usar contas de serviço com permissões mínimas
gcloud iam service-accounts create my-app-sa \
  --display-name="Conta de Serviço da Minha App"

# Conceder função específica
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'

Na entrevista, diga que evita papéis básicos em produção, separa identidades humanas e de workloads, prefere credenciais de curta duração e Workload Identity Federation, e revisa bindings de IAM regularmente.

2. Segurança de VPC:

Acesso Privado do Google
VPC Service Controls
Cloud Armor para proteção contra DDoS

3. Criptografia de Dados:

# Chaves de criptografia gerenciadas pelo cliente
gcloud kms keyrings create my-keyring \
  --location=global

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

# Usar com Cloud Storage
gsutil -o 'GSUtil:encryption_key=...' cp file.txt gs://my-bucket/

4. Monitoramento:

Cloud Audit Logs
Security Command Center
Cloud Logging e Monitoring

Raridade: Muito Comum Dificuldade: Difícil

Análise de Dados

7. Como você projeta e otimiza o BigQuery para análise em larga escala?

Resposta: BigQuery é o data warehouse serverless e altamente escalável do Google.

Arquitetura:

Armazenamento colunar
Escalabilidade automática
Interface SQL
Escala de petabytes
Preço por consulta

Design de Tabela:

-- Criar tabela particionada
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
);

-- Criar view materializada
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;

Estratégias de Otimização:

1. Particionamento:

-- Particionamento baseado em tempo
CREATE TABLE mydataset.sales
PARTITION BY DATE(sale_date)
AS SELECT * FROM source_table;

-- Particionamento por intervalo de inteiros
CREATE TABLE mydataset.user_data
PARTITION BY RANGE_BUCKET(user_id, GENERATE_ARRAY(0, 1000000, 10000))
AS SELECT * FROM source_table;

-- Consultar com filtro de partição (custo-efetivo)
SELECT *
FROM mydataset.events
WHERE DATE(event_timestamp) BETWEEN '2024-01-01' AND '2024-01-31'
  AND event_type = 'purchase';

2. Clustering:

-- Cluster por colunas frequentemente filtradas
CREATE TABLE mydataset.logs
PARTITION BY DATE(log_timestamp)
CLUSTER BY user_id, region, status
AS SELECT * FROM source_logs;

-- Consultas se beneficiam do clustering
SELECT *
FROM mydataset.logs
WHERE DATE(log_timestamp) = '2024-11-26'
  AND user_id = '12345'
  AND region = 'us-east1';

3. Otimização de Consulta:

-- Ruim: SELECT * (escaneia todas as colunas)
SELECT * FROM mydataset.large_table;

-- Bom: SELECT colunas específicas
SELECT user_id, event_type, event_timestamp
FROM mydataset.large_table;

-- Usar agregação aproximada para grandes datasets
SELECT APPROX_COUNT_DISTINCT(user_id) as unique_users
FROM mydataset.events;

-- Evitar auto-joins, usar window functions
SELECT
  user_id,
  event_timestamp,
  LAG(event_timestamp) OVER (PARTITION BY user_id ORDER BY event_timestamp) as prev_event
FROM mydataset.events;

4. Controle de Custos:

# Definir bytes máximos cobrados
bq query \
  --maximum_bytes_billed=1000000000 \
  --use_legacy_sql=false \
  'SELECT COUNT(*) FROM mydataset.large_table'

# Dry run para estimar custos
bq query \
  --dry_run \
  --use_legacy_sql=false \
  'SELECT * FROM mydataset.large_table'

Carregamento de Dados:

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

# Carregar com schema
bq load \
  --source_format=CSV \
  --skip_leading_rows=1 \
  mydataset.mytable \
  gs://mybucket/data.csv \
  schema.json

# Streaming inserts (tempo real)
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}")

Melhores Práticas:

Sempre use filtros de partição
Cluster por colunas de alta cardinalidade
Evite SELECT *
Use funções aproximadas para grandes datasets
Monitore os custos de consulta
Use views materializadas para consultas repetidas
Desnormalize os dados quando apropriado

Raridade: Muito Comum Dificuldade: Difícil

Serviços Avançados de Banco de Dados

8. Quando você usaria Cloud Spanner vs Cloud SQL?

Resposta: Escolha com base na escala, consistência e requisitos geográficos:

Cloud Spanner:

Banco de dados relacional distribuído globalmente
Escalabilidade horizontal (ilimitada)
Consistência forte entre regiões
SLA de 99.999% de disponibilidade
Custo mais alto

Cloud SQL:

Banco de dados gerenciado regional (MySQL, PostgreSQL, SQL Server)
Escalabilidade vertical (limitada)
Região única (com réplicas de leitura)
SLA de 99.95% de disponibilidade
Custo mais baixo

Comparação:

Característica	Cloud Spanner	Cloud SQL
Escala	Petabytes	Terabytes
Consistência	Forte global	Regional
Disponibilidade	99.999%	99.95%
Latência	Milissegundos de um dígito globalmente	Baixa (regional)
Custo	Alto	Moderado
Caso de Uso	Apps globais, sistemas financeiros	Apps regionais, cargas de trabalho tradicionais

Exemplo de Cloud Spanner:

-- Criar instância Spanner
gcloud spanner instances create my-instance \
  --config=regional-us-central1 \
  --nodes=3 \
  --description="Instância de Produção"

-- Criar banco de dados
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)'

-- Inserir dados
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())"

-- Consultar com consistência forte
gcloud spanner databases execute-sql my-database \
  --instance=my-instance \
  --sql="SELECT * FROM Users WHERE UserId = 1"

Cliente Python:

from google.cloud import spanner

# Criar cliente
spanner_client = spanner.Client()
instance = spanner_client.instance('my-instance')
database = instance.database('my-database')

# Ler com consistência forte
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"Usuário: {row[0]}, {row[1]}, {row[2]}")

# Escrever com transação
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)

Exemplo de Cloud SQL:

# Criar instância Cloud SQL
gcloud sql instances create my-instance \
  --database-version=POSTGRES_14 \
  --tier=db-n1-standard-2 \
  --region=us-central1 \
  --root-password=mypassword

# Criar banco de dados
gcloud sql databases create mydatabase \
  --instance=my-instance

# Conectar
gcloud sql connect my-instance --user=postgres

# Criar réplica de leitura
gcloud sql instances create my-replica \
  --master-instance-name=my-instance \
  --tier=db-n1-standard-1 \
  --region=us-east1

Quando Usar:

Use Cloud Spanner quando:

Precisar de distribuição global
Requerer consistência forte entre regiões
Escalar além de uma única região
Transações financeiras
Aplicações de missão crítica
Orçamento permite um custo mais alto

Use Cloud SQL quando:

Aplicação regional
Familiarizado com MySQL/PostgreSQL
Sensível a custos
Escala moderada (< 10TB)
Cargas de trabalho SQL existentes
Não precisa de consistência global

Raridade: Comum Dificuldade: Média-Difícil

Segurança & Compliance

9. Como você implementa VPC Service Controls?

Resposta: VPC Service Controls cria perímetros de segurança em torno dos recursos do GCP para evitar a exfiltração de dados.

Conceitos Chave:

Service Perimeter: Limite em torno dos recursos
Access Levels: Condições para acesso
Ingress/Egress Rules: Controlar o fluxo de dados

Arquitetura:

Loading diagram...

Configuração:

# Criar política de acesso
gcloud access-context-manager policies create \
  --organization=123456789 \
  --title="Política de Produção"

# Criar nível de acesso
gcloud access-context-manager levels create CorpNetwork \
  --policy=accessPolicies/123456789 \
  --title="Rede Corporativa" \
  --basic-level-spec=access_level.yaml

# access_level.yaml
conditions:
  - ipSubnetworks:
    - 203.0.113.0/24  # Intervalo de IP corporativo
  - members:
    - user:[email protected]

Criar Service Perimeter:

# Criar perímetro
gcloud access-context-manager perimeters create production_perimeter \
  --policy=accessPolicies/123456789 \
  --title="Perímetro de Produção" \
  --resources=projects/123456789012 \
  --restricted-services=storage.googleapis.com,bigquery.googleapis.com \
  --access-levels=accessPolicies/123456789/accessLevels/CorpNetwork

# Adicionar projeto ao perímetro
gcloud access-context-manager perimeters update production_perimeter \
  --policy=accessPolicies/123456789 \
  --add-resources=projects/987654321098

Regras de Entrada/Saída (Ingress/Egress Rules):

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

# Aplicar regra de entrada
gcloud access-context-manager perimeters update production_perimeter \
  --policy=accessPolicies/123456789 \
  --set-ingress-policies=ingress_rule.yaml

Regras de Saída (Egress Rules):

# 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'

# Aplicar regra de saída
gcloud access-context-manager perimeters update production_perimeter \
  --policy=accessPolicies/123456789 \
  --set-egress-policies=egress_rule.yaml

Serviços Suportados:

Cloud Storage
BigQuery
Cloud SQL
Compute Engine
GKE
Cloud Functions
E muitos mais

Testes:

# Testar acesso de dentro do perímetro
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"Acesso concedido: {len(blobs)} objetos")
    except Exception as e:
        print(f"Acesso negado: {e}")

# Isso terá sucesso da rede autorizada
# Isso falhará da rede não autorizada
test_access()

Monitoramento:

# Visualizar logs do VPC SC
gcloud logging read \
  'protoPayload.metadata.@type="type.googleapis.com/google.cloud.audit.VpcServiceControlAuditMetadata"' \
  --limit=50 \
  --format=json

Casos de Uso:

Evitar exfiltração de dados
Requisitos de conformidade (HIPAA, PCI-DSS)
Proteger dados sensíveis
Isolar ambientes de produção
Segurança multi-tenant

Melhores Práticas:

Comece com o modo dry-run
Teste completamente antes da aplicação
Use níveis de acesso para controle refinado
Monitore os logs do VPC SC
Documente os limites do perímetro
Revisões de acesso regulares

Raridade: Incomum Dificuldade: Difícil

Conclusão

Entrevistas para engenheiros de nuvem GCP seniores exigem profundo conhecimento técnico e experiência prática. Foque em:

Arquitetura: Alta disponibilidade, escalabilidade, recuperação de desastres
GKE: Orquestração de contêineres, estratégias de implantação
Serverless: Casos de uso de Cloud Functions, Cloud Run
Rede: VPC Compartilhado, conectividade híbrida
Otimização de Custos: Dimensionamento adequado, uso comprometido, políticas de ciclo de vida
Segurança: IAM, criptografia, controles de VPC

Quando possível, conecte sua resposta a um incidente, migração, revisão de custos ou melhoria de confiabilidade que você conduziu. Isso é mais forte do que apenas listar serviços.

Conselhos de carreira recentes

Perguntas de entrevista para Senior GCP Cloud Engineer

Introdução

Arquitetura & Design

1. Desenhe uma aplicação de alta disponibilidade no GCP.

Google Kubernetes Engine (GKE)

2. Como você implanta e gerencia aplicações no GKE?

Serverless & Serviços Avançados

3. Quando você usaria Cloud Functions vs Cloud Run?

Rede Avançada

4. Explique VPC Compartilhado e quando usá-lo.

Otimização de Custos

5. Como você otimiza os custos do GCP?

Segurança

6. Como você implementa as melhores práticas de segurança no GCP?

Análise de Dados

7. Como você projeta e otimiza o BigQuery para análise em larga escala?

Serviços Avançados de Banco de Dados

8. Quando você usaria Cloud Spanner vs Cloud SQL?

Segurança & Compliance

9. Como você implementa VPC Service Controls?

Conclusão

Dicas de carreira semanais que realmente funcionam

Dicas de carreira semanais que realmente funcionam

Posts Relacionados

Perguntas de Entrevista Senior Azure Cloud Engineer: guia por cenários

Perguntas de entrevista para Senior AWS Cloud Engineer

Perguntas de entrevista para engenheiro de segurança sênior

Pare de Se Candidatar. Comece a Ser Contratado.

Compartilhar esta publicação

Seja Contratado 50% Mais Rápido