Domande colloquio Senior GCP Cloud Engineer

Introduzione

I colloqui per Senior GCP Cloud Engineer verificano soprattutto se sai giustificare decisioni di produzione, non solo citare servizi Google Cloud. Preparati a spiegare quando scegliere GKE, Cloud Run, Cloud SQL, Spanner, Shared VPC, controlli IAM e guardrail di costo per un workload specifico.

Usa queste domande per esercitarti con risposte da senior: parti dal requisito, motiva la scelta, evidenzia i rischi e spiega come gestiresti il sistema in produzione.

Architettura e Design

1. Progetta un'applicazione ad alta disponibilità su GCP.

Risposta: Architettura pronta per la produzione con ridondanza e scalabilità:

Loading diagram...

Componenti Chiave:

# Crea un gruppo di istanze gestite con autoscaling
gcloud compute instance-groups managed create my-mig \
  --base-instance-name=my-app \
  --template=my-template \
  --size=3 \
  --zone=us-central1-a

# Configura l'autoscaling
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

# Crea un load balancer
gcloud compute backend-services create my-backend \
  --protocol=HTTP \
  --health-checks=my-health-check \
  --global

# Aggiungi il gruppo di istanze al backend
gcloud compute backend-services add-backend my-backend \
  --instance-group=my-mig \
  --instance-group-zone=us-central1-a \
  --global

Principi di Progettazione:

Deploy multi-zona
Auto-scaling basato su metriche
Servizi gestiti per i database
CDN per contenuti statici
Controlli di integrità e monitoraggio

Rarità: Molto Comune Difficoltà: Difficile

Google Kubernetes Engine (GKE)

2. Come distribuisci e gestisci le applicazioni su GKE?

Risposta: GKE è il servizio Kubernetes gestito di Google.

Processo di Distribuzione:

# Crea un 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

# Ottieni le credenziali
gcloud container clusters get-credentials my-cluster \
  --zone=us-central1-a

# Distribuisci l'applicazione
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

Funzionalità GKE da citare:

Cluster regionali per disponibilità del control plane e dei nodi
Cluster autoscaling più Horizontal Pod Autoscaling
Workload Identity Federation for GKE invece di chiavi di service account a lunga durata
Binary Authorization e image scanning per il controllo della supply chain
Cloud Logging, Cloud Monitoring, SLO e alerting

Rarità: Molto Comune Difficoltà: Difficile

Serverless e Servizi Avanzati

3. Quando useresti Cloud Functions rispetto a Cloud Run?

Risposta: Scegli in base al contratto operativo che devi assumere. Una risposta forte confronta trigger, packaging, controllo del runtime, scalabilità e complessità operativa.

Cloud Functions:

Ideale per piccoli handler di eventi Pub/Sub, Cloud Storage, Eventarc o HTTP semplice
Superficie infrastrutturale minima
Utile quando il team vuole deployment a livello funzione e non richiede container personalizzati
Meno controllo sul runtime rispetto a un servizio containerizzato

Cloud Run:

Ideale per servizi HTTP, API, worker e servizi event-driven containerizzati
Più controllo su dipendenze, concorrenza, CPU, avvio e traffic splitting
Scala a zero, ma può usare istanze minime per percorsi sensibili alla latenza
Spesso è la scelta migliore quando servono portabilità, runtime personalizzato o responsabilità a livello di servizio

# Esempio di Cloud Function
def hello_pubsub(event, context):
    """Attivato da un messaggio Pub/Sub"""
    import base64
    
    if 'data' in event:
        message = base64.b64decode(event['data']).decode('utf-8')
        print(f'Messaggio ricevuto: {message}')
        
        # Elabora il messaggio
        process_data(message)

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

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

Rarità: Comune Difficoltà: Media

Networking Avanzato

4. Spiega Shared VPC e quando usarlo.

Risposta: Shared VPC consente a più progetti di condividere una rete VPC comune.

Vantaggi:

Amministrazione di rete centralizzata
Condivisione di risorse tra progetti
Fatturazione semplificata
Politiche di sicurezza coerenti

Architettura:

Loading diagram...

# Abilita Shared VPC nel progetto host
gcloud compute shared-vpc enable my-host-project

# Allega il progetto di servizio
gcloud compute shared-vpc associated-projects add my-service-project \
  --host-project=my-host-project

# Concedi i permessi
gcloud projects add-iam-policy-binding my-host-project \
  --member=serviceAccount:[email protected] \
  --role=roles/compute.networkUser

Casi d'Uso:

Grandi organizzazioni
Ambienti multi-team
Gestione di rete centralizzata
Requisiti di conformità

Rarità: Comune Difficoltà: Medio-Difficile

Ottimizzazione dei Costi

5. Come ottimizzi i costi di GCP?

Risposta: Strategie di ottimizzazione dei costi:

1. Right-sizing:

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

2. Sconti per Utilizzo Continuativo:

Impegni di 1 o 3 anni per workload prevedibili
Impegni flessibili per pattern di spesa; impegni basati sulle risorse per uso compute specifico
Da abbinare al right-sizing per non bloccare sprechi

3. Spot VM:

# Crea una Spot VM per lavoro interrompibile
gcloud compute instances create my-spot-vm \
  --provisioning-model=SPOT \
  --machine-type=e2-medium

4. Ciclo di Vita dello Storage:

# Imposta la policy del ciclo di vita
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. Monitoraggio:

Report di Cloud Billing
Avvisi di budget
Ripartizione dei costi per servizio/progetto

Rarità: Molto Comune Difficoltà: Media

Sicurezza

6. Come implementi le migliori pratiche di sicurezza in GCP?

Risposta: Usa un modello a livelli: prima l'identità, reti private dove riducono l'esposizione, crittografia per dati sensibili e rilevamento continuo con log e Security Command Center.

1. Best Practices IAM:

# Usa account di servizio con permessi minimi
gcloud iam service-accounts create my-app-sa \
  --display-name="Account di Servizio della Mia App"

# Concedi un ruolo specifico
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'

Nel colloquio, spiega che eviti i ruoli basic in produzione, separi identità umane e workload, preferisci credenziali a breve durata e Workload Identity Federation, e rivedi regolarmente i binding IAM.

2. Sicurezza VPC:

Accesso Privato a Google
VPC Service Controls
Cloud Armor per la protezione DDoS

3. Crittografia dei Dati:

# Chiavi di crittografia gestite dal cliente
gcloud kms keyrings create my-keyring \
  --location=global

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

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

4. Monitoraggio:

Cloud Audit Logs
Security Command Center
Cloud Logging e Monitoring

Rarità: Molto Comune Difficoltà: Difficile

Analisi dei Dati

7. Come progetti e ottimizzi BigQuery per l'analisi su larga scala?

Risposta: BigQuery è il data warehouse serverless e altamente scalabile di Google.

Architettura:

Storage colonnare
Scaling automatico
Interfaccia SQL
Scala di petabyte
Prezzi pay-per-query

Design delle Tabelle:

-- Crea una tabella partizionata
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
);

-- Crea una materialized view
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;

Strategie di Ottimizzazione:

1. Partizionamento:

-- Partizionamento basato sul tempo
CREATE TABLE mydataset.sales
PARTITION BY DATE(sale_date)
AS SELECT * FROM source_table;

-- Partizionamento per intervallo di interi
CREATE TABLE mydataset.user_data
PARTITION BY RANGE_BUCKET(user_id, GENERATE_ARRAY(0, 1000000, 10000))
AS SELECT * FROM source_table;

-- Query con filtro di partizione (economico)
SELECT *
FROM mydataset.events
WHERE DATE(event_timestamp) BETWEEN '2024-01-01' AND '2024-01-31'
  AND event_type = 'purchase';

2. Clustering:

-- Clustera per colonne filtrate frequentemente
CREATE TABLE mydataset.logs
PARTITION BY DATE(log_timestamp)
CLUSTER BY user_id, region, status
AS SELECT * FROM source_logs;

-- Le query beneficiano del clustering
SELECT *
FROM mydataset.logs
WHERE DATE(log_timestamp) = '2024-11-26'
  AND user_id = '12345'
  AND region = 'us-east1';

3. Ottimizzazione delle Query:

-- Sbagliato: SELECT * (scansiona tutte le colonne)
SELECT * FROM mydataset.large_table;

-- Giusto: SELECT colonne specifiche
SELECT user_id, event_type, event_timestamp
FROM mydataset.large_table;

-- Usa l'aggregazione approssimativa per dataset di grandi dimensioni
SELECT APPROX_COUNT_DISTINCT(user_id) as unique_users
FROM mydataset.events;

-- Evita self-join, usa 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. Controllo dei Costi:

# Imposta il numero massimo di byte fatturati
bq query \
  --maximum_bytes_billed=1000000000 \
  --use_legacy_sql=false \
  'SELECT COUNT(*) FROM mydataset.large_table'

# Dry run per stimare i costi
bq query \
  --dry_run \
  --use_legacy_sql=false \
  'SELECT * FROM mydataset.large_table'

Caricamento dei Dati:

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

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

# Streaming inserts (real-time)
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"Errori: {errors}")

Best Practices:

Usa sempre i filtri di partizione
Clustera per colonne ad alta cardinalità
Evita SELECT *
Usa funzioni approssimative per dataset di grandi dimensioni
Monitora i costi delle query
Usa materialized views per query ripetute
Denormalizza i dati quando appropriato

Rarità: Molto Comune Difficoltà: Difficile

Servizi di Database Avanzati

8. Quando useresti Cloud Spanner rispetto a Cloud SQL?

Risposta: Scegli in base a scala, coerenza e requisiti geografici:

Cloud Spanner:

Database relazionale distribuito globalmente
Scaling orizzontale (illimitato)
Coerenza forte tra le regioni
SLA di disponibilità del 99,999%
Costo più elevato

Cloud SQL:

Database gestito regionale (MySQL, PostgreSQL, SQL Server)
Scaling verticale (limitato)
Singola regione (con repliche di lettura)
SLA di disponibilità del 99,95%
Costo inferiore

Confronto:

Caratteristica	Cloud Spanner	Cloud SQL
Scala	Petabyte	Terabyte
Coerenza	Forte globale	Regionale
Disponibilità	99,999%	99,95%
Latenza	Ms a singola cifra a livello globale	Bassa (regionale)
Costo	Alto	Moderato
Caso d'Uso	App globali, sistemi finanziari	App regionali, carichi di lavoro tradizionali

Esempio di Cloud Spanner:

-- Crea un'istanza di Spanner
gcloud spanner instances create my-instance \
  --config=regional-us-central1 \
  --nodes=3 \
  --description="Istanza di produzione"

-- Crea un database
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)'

-- Inserisci dati
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())"

-- Query con forte coerenza
gcloud spanner databases execute-sql my-database \
  --instance=my-instance \
  --sql="SELECT * FROM Users WHERE UserId = 1"

Client Python:

from google.cloud import spanner

# Crea un client
spanner_client = spanner.Client()
instance = spanner_client.instance('my-instance')
database = instance.database('my-database')

# Leggi con forte coerenza
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"Utente: {row[0]}, {row[1]}, {row[2]}")

# Scrivi con transazione
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)

Esempio di Cloud SQL:

# Crea un'istanza di Cloud SQL
gcloud sql instances create my-instance \
  --database-version=POSTGRES_14 \
  --tier=db-n1-standard-2 \
  --region=us-central1 \
  --root-password=mypassword

# Crea un database
gcloud sql databases create mydatabase \
  --instance=my-instance

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

# Crea una replica di lettura
gcloud sql instances create my-replica \
  --master-instance-name=my-instance \
  --tier=db-n1-standard-1 \
  --region=us-east1

Quando Usare:

Usa Cloud Spanner quando:

Hai bisogno di distribuzione globale
Richiedi forte coerenza tra le regioni
Scala oltre una singola regione
Transazioni finanziarie
Applicazioni mission-critical
Il budget consente un costo più elevato

Usa Cloud SQL quando:

Applicazione regionale
Familiarità con MySQL/PostgreSQL
Sensibile ai costi
Scala moderata (< 10TB)
Carichi di lavoro SQL esistenti
Non hai bisogno di coerenza globale

Rarità: Comune Difficoltà: Medio-Difficile

Sicurezza e Conformità

9. Come implementi VPC Service Controls?

Risposta: VPC Service Controls crea perimetri di sicurezza attorno alle risorse GCP per prevenire l'esfiltrazione dei dati.

Concetti Chiave:

Perimetro di Servizio: Confine attorno alle risorse
Livelli di Accesso: Condizioni per l'accesso
Regole di Ingress/Egress: Controlla il flusso di dati

Architettura:

Loading diagram...

Configurazione:

# Crea una policy di accesso
gcloud access-context-manager policies create \
  --organization=123456789 \
  --title="Policy di Produzione"

# Crea un livello di accesso
gcloud access-context-manager levels create CorpNetwork \
  --policy=accessPolicies/123456789 \
  --title="Rete Aziendale" \
  --basic-level-spec=access_level.yaml

# access_level.yaml
conditions:
  - ipSubnetworks:
    - 203.0.113.0/24  # Intervallo IP aziendale
  - members:
    - user:[email protected]

Crea un Perimetro di Servizio:

# Crea un perimetro
gcloud access-context-manager perimeters create production_perimeter \
  --policy=accessPolicies/123456789 \
  --title="Perimetro di Produzione" \
  --resources=projects/123456789012 \
  --restricted-services=storage.googleapis.com,bigquery.googleapis.com \
  --access-levels=accessPolicies/123456789/accessLevels/CorpNetwork

# Aggiungi un progetto al perimetro
gcloud access-context-manager perimeters update production_perimeter \
  --policy=accessPolicies/123456789 \
  --add-resources=projects/987654321098

Regole di Ingress/Egress:

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

# Applica la regola di ingress
gcloud access-context-manager perimeters update production_perimeter \
  --policy=accessPolicies/123456789 \
  --set-ingress-policies=ingress_rule.yaml

Regole di Egress:

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

# Applica la regola di egress
gcloud access-context-manager perimeters update production_perimeter \
  --policy=accessPolicies/123456789 \
  --set-egress-policies=egress_rule.yaml

Servizi Supportati:

Cloud Storage
BigQuery
Cloud SQL
Compute Engine
GKE
Cloud Functions
E molti altri

Test:

# Testa l'accesso dall'interno del perimetro
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"Accesso consentito: {len(blobs)} oggetti")
    except Exception as e:
        print(f"Accesso negato: {e}")

# Questo avrà successo dalla rete autorizzata
# Questo fallirà dalla rete non autorizzata
test_access()

Monitoraggio:

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

Casi d'Uso:

Prevenire l'esfiltrazione dei dati
Requisiti di conformità (HIPAA, PCI-DSS)
Proteggere dati sensibili
Isolare ambienti di produzione
Sicurezza multi-tenant

Best Practices:

Inizia con la modalità dry-run
Testa a fondo prima dell'applicazione
Usa livelli di accesso per un controllo granulare
Monitora i log VPC SC
Documenta i confini del perimetro
Revisioni periodiche degli accessi

Rarità: Non Comune Difficoltà: Difficile

Conclusione

I colloqui per senior GCP cloud engineer richiedono una profonda conoscenza tecnica ed esperienza pratica. Concentrati su:

Architettura: Alta disponibilità, scalabilità, disaster recovery
GKE: Orchestrazione di container, strategie di deployment
Serverless: Casi d'uso di Cloud Functions, Cloud Run
Networking: Shared VPC, connettività ibrida
Ottimizzazione dei Costi: Right-sizing, utilizzo continuativo, policy del ciclo di vita
Sicurezza: IAM, crittografia, controlli VPC

Quando puoi, collega la risposta a un incidente, una migrazione, una revisione dei costi o un miglioramento dell'affidabilità che hai gestito. Vale più di un semplice elenco di servizi.

Consigli di carriera recenti

Domande di colloquio per Senior GCP Cloud Engineer

Introduzione

Architettura e Design

1. Progetta un'applicazione ad alta disponibilità su GCP.

Google Kubernetes Engine (GKE)

2. Come distribuisci e gestisci le applicazioni su GKE?

Serverless e Servizi Avanzati

3. Quando useresti Cloud Functions rispetto a Cloud Run?

Networking Avanzato

4. Spiega Shared VPC e quando usarlo.

Ottimizzazione dei Costi

5. Come ottimizzi i costi di GCP?

Sicurezza

6. Come implementi le migliori pratiche di sicurezza in GCP?

Analisi dei Dati

7. Come progetti e ottimizzi BigQuery per l'analisi su larga scala?

Servizi di Database Avanzati

8. Quando useresti Cloud Spanner rispetto a Cloud SQL?

Sicurezza e Conformità

9. Come implementi VPC Service Controls?

Conclusione

Consigli di carriera settimanali che funzionano davvero

Consigli di carriera settimanali che funzionano davvero

Post Correlati

Domande da colloquio per Senior AWS Cloud Engineer

Domande da Colloquio Senior Azure Cloud Engineer: guida a scenari

Domande di colloquio per Senior Security Engineer

Smetti di Candidarti. Inizia a Essere Assunto.

Condividi questo post

Raddoppia le Tue Chiamate per Colloqui