Questions d'entretien Senior GCP Cloud Engineer

Introduction

Un entretien Senior GCP Cloud Engineer teste surtout votre capacité à justifier des choix de production, pas seulement à citer des services Google Cloud. Préparez-vous à expliquer pourquoi choisir GKE, Cloud Run, Cloud SQL, Spanner, Shared VPC, des contrôles IAM et des garde-fous de coûts pour une charge donnée.

Utilisez ces questions pour travailler des réponses de niveau senior : partez du besoin, justifiez le choix, nommez les risques et expliquez l'exploitation en production.

Architecture et conception

1. Concevez une application à haute disponibilité sur GCP.

Réponse: Architecture prête pour la production avec redondance et évolutivité :

Loading diagram...

Composants clés :

# Créer un groupe d'instances géré avec mise à l'échelle automatique
gcloud compute instance-groups managed create my-mig \
  --base-instance-name=my-app \
  --template=my-template \
  --size=3 \
  --zone=us-central1-a

# Configurer la mise à l'échelle automatique
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

# Créer un équilibreur de charge
gcloud compute backend-services create my-backend \
  --protocol=HTTP \
  --health-checks=my-health-check \
  --global

# Ajouter un groupe d'instances au backend
gcloud compute backend-services add-backend my-backend \
  --instance-group=my-mig \
  --instance-group-zone=us-central1-a \
  --global

Principes de conception :

Déploiement multi-zone
Mise à l'échelle automatique basée sur des métriques
Services gérés pour les bases de données
CDN pour le contenu statique
Contrôles de santé et surveillance

Rareté : Très courant Difficulté : Difficile

Google Kubernetes Engine (GKE)

2. Comment déployez-vous et gérez-vous des applications sur GKE ?

Réponse : GKE est le service Kubernetes géré de Google.

Processus de déploiement :

# Créer 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

# Obtenir les informations d'identification
gcloud container clusters get-credentials my-cluster \
  --zone=us-central1-a

# Déployer l'application
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

Fonctionnalités GKE à mentionner :

Clusters régionaux pour la disponibilité du plan de contrôle et des nœuds
Cluster autoscaling avec Horizontal Pod Autoscaling
Workload Identity Federation for GKE au lieu de clés de compte de service durables
Binary Authorization et analyse d'images pour la chaîne d'approvisionnement
Cloud Logging, Cloud Monitoring, SLO et alertes

Rareté : Très courant Difficulté : Difficile

Services sans serveur et avancés

3. Quand utiliseriez-vous Cloud Functions plutôt que Cloud Run ?

Réponse : Choisissez selon le contrat opérationnel à assumer. Une bonne réponse compare déclencheurs, packaging, contrôle du runtime, comportement de mise à l'échelle et complexité d'exploitation.

Cloud Functions :

Idéal pour de petits gestionnaires d'événements Pub/Sub, Cloud Storage, Eventarc ou HTTP simple
Surface d'infrastructure minimale
Utile quand l'équipe veut déployer au niveau fonction sans conteneur personnalisé
Moins de contrôle sur le runtime qu'un service conteneurisé

Cloud Run :

Idéal pour services HTTP, API, workers et services événementiels conteneurisés
Plus de contrôle sur dépendances, concurrence, CPU, démarrage et répartition du trafic
Mise à l'échelle à zéro, avec possibilité d'instances minimales pour les chemins sensibles à la latence
Souvent préférable si vous avez besoin de portabilité, d'un runtime personnalisé ou d'une responsabilité au niveau service

# Exemple de Cloud Function
def hello_pubsub(event, context):
    """Déclenché par un message Pub/Sub"""
    import base64
    
    if 'data' in event:
        message = base64.b64decode(event['data']).decode('utf-8')
        print(f'Message reçu : {message}')
        
        # Traiter le message
        process_data(message)

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

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

Rareté : Courant Difficulté : Moyen

Mise en réseau avancée

4. Expliquez VPC partagé et quand l'utiliser.

Réponse : Le VPC partagé permet à plusieurs projets de partager un réseau VPC commun.

Avantages :

Administration centralisée du réseau
Partage de ressources entre les projets
Facturation simplifiée
Politiques de sécurité cohérentes

Architecture :

Loading diagram...

# Activer le VPC partagé dans le projet hôte
gcloud compute shared-vpc enable my-host-project

# Attacher le projet de service
gcloud compute shared-vpc associated-projects add my-service-project \
  --host-project=my-host-project

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

Cas d'utilisation :

Grandes organisations
Environnements multi-équipes
Gestion centralisée du réseau
Exigences de conformité

Rareté : Courant Difficulté : Moyen-Difficile

Optimisation des coûts

5. Comment optimisez-vous les coûts GCP ?

Réponse : Stratégies d'optimisation des coûts :

1. Dimensionnement approprié :

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

2. Remises sur engagement d'utilisation :

Engagements d'un ou trois ans pour les charges prévisibles
Engagements flexibles pour les modèles de dépenses; engagements par ressource pour une consommation compute précise
À combiner avec le dimensionnement pour ne pas verrouiller du gaspillage

3. Spot VMs :

# Créer une Spot VM pour du travail interruptible
gcloud compute instances create my-spot-vm \
  --provisioning-model=SPOT \
  --machine-type=e2-medium

4. Cycle de vie du stockage :

# Définir la politique de cycle de vie
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. Surveillance :

Rapports Cloud Billing
Alertes de budget
Ventilation des coûts par service/projet

Rareté : Très courant Difficulté : Moyen

Sécurité

6. Comment mettez-vous en œuvre les meilleures pratiques de sécurité dans GCP ?

Réponse : Utilisez une approche en couches : identité d'abord, réseau privé quand il réduit l'exposition, chiffrement des données sensibles et détection continue via les logs et Security Command Center.

1. Meilleures pratiques IAM :

# Utiliser des comptes de service avec des autorisations minimales
gcloud iam service-accounts create my-app-sa \
  --display-name="Mon compte de service d'application"

# Accorder un rôle spécifique
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'

En entretien, précisez que vous évitez les rôles de base en production, séparez identités humaines et workloads, privilégiez les identifiants courts et Workload Identity Federation, et revoyez régulièrement les bindings IAM.

2. Sécurité VPC :

Accès privé à Google
Contrôles de service VPC
Cloud Armor pour la protection DDoS

3. Chiffrement des données :

# Clés de chiffrement gérées par le client
gcloud kms keyrings create my-keyring \
  --location=global

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

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

4. Surveillance :

Journaux d'audit Cloud
Security Command Center
Cloud Logging et Monitoring

Rareté : Très courant Difficulté : Difficile

Analyse des données

7. Comment concevez-vous et optimisez-vous BigQuery pour l'analyse à grande échelle ?

Réponse : BigQuery est l'entrepôt de données sans serveur et hautement évolutif de Google.

Architecture :

Stockage en colonnes
Mise à l'échelle automatique
Interface SQL
Échelle du pétaoctet
Tarification à la requête

Conception de la table :

-- Créer une table partitionnée
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
);

-- Créer une vue matérialisée
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;

Stratégies d'optimisation :

1. Partitionnement :

-- Partitionnement basé sur le temps
CREATE TABLE mydataset.sales
PARTITION BY DATE(sale_date)
AS SELECT * FROM source_table;

-- Partitionnement par plage d'entiers
CREATE TABLE mydataset.user_data
PARTITION BY RANGE_BUCKET(user_id, GENERATE_ARRAY(0, 1000000, 10000))
AS SELECT * FROM source_table;

-- Requête avec filtre de partition (rentable)
SELECT *
FROM mydataset.events
WHERE DATE(event_timestamp) BETWEEN '2024-01-01' AND '2024-01-31'
  AND event_type = 'purchase';

2. Clustering :

-- Cluster par colonnes fréquemment filtrées
CREATE TABLE mydataset.logs
PARTITION BY DATE(log_timestamp)
CLUSTER BY user_id, region, status
AS SELECT * FROM source_logs;

-- Les requêtes bénéficient du clustering
SELECT *
FROM mydataset.logs
WHERE DATE(log_timestamp) = '2024-11-26'
  AND user_id = '12345'
  AND region = 'us-east1';

3. Optimisation des requêtes :

-- Mauvais : SELECT * (analyse toutes les colonnes)
SELECT * FROM mydataset.large_table;

-- Bien : SELECT des colonnes spécifiques
SELECT user_id, event_type, event_timestamp
FROM mydataset.large_table;

-- Utiliser l'agrégation approximative pour les grands ensembles de données
SELECT APPROX_COUNT_DISTINCT(user_id) as unique_users
FROM mydataset.events;

-- Éviter les auto-jointures, utiliser les fonctions de fenêtre
SELECT
  user_id,
  event_timestamp,
  LAG(event_timestamp) OVER (PARTITION BY user_id ORDER BY event_timestamp) as prev_event
FROM mydataset.events;

4. Contrôle des coûts :

# Définir le nombre maximal d'octets facturés
bq query \
  --maximum_bytes_billed=1000000000 \
  --use_legacy_sql=false \
  'SELECT COUNT(*) FROM mydataset.large_table'

# Exécution à blanc pour estimer les coûts
bq query \
  --dry_run \
  --use_legacy_sql=false \
  'SELECT * FROM mydataset.large_table'

Chargement des données :

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

# Charger avec le schéma
bq load \
  --source_format=CSV \
  --skip_leading_rows=1 \
  mydataset.mytable \
  gs://mybucket/data.csv \
  schema.json

# Inserts en flux continu (en temps réel)
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"Erreurs : {errors}")

Meilleures pratiques :

Toujours utiliser des filtres de partition
Cluster par colonnes à cardinalité élevée
Éviter SELECT *
Utiliser des fonctions approximatives pour les grands ensembles de données
Surveiller les coûts des requêtes
Utiliser des vues matérialisées pour les requêtes répétées
Dénormaliser les données le cas échéant

Rareté : Très courant Difficulté : Difficile

Services de base de données avancés

8. Quand utiliseriez-vous Cloud Spanner plutôt que Cloud SQL ?

Réponse : Choisissez en fonction de l'échelle, de la cohérence et des exigences géographiques :

Cloud Spanner :

Base de données relationnelle distribuée mondialement
Mise à l'échelle horizontale (illimitée)
Forte cohérence entre les régions
SLA de disponibilité de 99,999 %
Coût plus élevé

Cloud SQL :

Base de données gérée régionale (MySQL, PostgreSQL, SQL Server)
Mise à l'échelle verticale (limitée)
Région unique (avec des réplicas en lecture)
SLA de disponibilité de 99,95 %
Coût inférieur

Comparaison :

Caractéristique	Cloud Spanner	Cloud SQL
Échelle	Pétaoctets	Téraoctets
Cohérence	Forte mondiale	Régionale
Disponibilité	99,999 %	99,95 %
Latence	Chiffre unique en ms à l'échelle mondiale	Faible (régionale)
Coût	Élevé	Modéré
Cas d'utilisation	Applications mondiales, systèmes financiers	Applications régionales, charges de travail traditionnelles

Exemple de Cloud Spanner :

-- Créer une instance Spanner
gcloud spanner instances create my-instance \
  --config=regional-us-central1 \
  --nodes=3 \
  --description="Instance de production"

-- Créer une base de données
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)'

-- Insérer des données
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())"

-- Requête avec une forte cohérence
gcloud spanner databases execute-sql my-database \
  --instance=my-instance \
  --sql="SELECT * FROM Users WHERE UserId = 1"

Client Python :

from google.cloud import spanner

# Créer un client
spanner_client = spanner.Client()
instance = spanner_client.instance('my-instance')
database = instance.database('my-database')

# Lire avec une forte cohérence
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"Utilisateur : {row[0]}, {row[1]}, {row[2]}")

# Écrire avec une transaction
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)

Exemple de Cloud SQL :

# Créer une instance Cloud SQL
gcloud sql instances create my-instance \
  --database-version=POSTGRES_14 \
  --tier=db-n1-standard-2 \
  --region=us-central1 \
  --root-password=mypassword

# Créer une base de données
gcloud sql databases create mydatabase \
  --instance=my-instance

# Se connecter
gcloud sql connect my-instance --user=postgres

# Créer un réplica en lecture
gcloud sql instances create my-replica \
  --master-instance-name=my-instance \
  --tier=db-n1-standard-1 \
  --region=us-east1

Quand utiliser :

Utiliser Cloud Spanner lorsque :

Besoin d'une distribution mondiale
Nécessité d'une forte cohérence entre les régions
Mise à l'échelle au-delà d'une seule région
Transactions financières
Applications critiques
Budget permettant un coût plus élevé

Utiliser Cloud SQL lorsque :

Application régionale
Familiarité avec MySQL/PostgreSQL
Sensibilité aux coûts
Échelle modérée (< 10 To)
Charges de travail SQL existantes
Pas besoin de cohérence globale

Rareté : Courant Difficulté : Moyen-Difficile

Sécurité et conformité

9. Comment mettez-vous en œuvre les contrôles de service VPC ?

Réponse : Les contrôles de service VPC créent des périmètres de sécurité autour des ressources GCP pour empêcher l'exfiltration de données.

Concepts clés :

Périmètre de service : Limite autour des ressources
Niveaux d'accès : Conditions d'accès
Règles d'entrée/sortie : Contrôler le flux de données

Architecture :

Loading diagram...

Configuration :

# Créer une stratégie d'accès
gcloud access-context-manager policies create \
  --organization=123456789 \
  --title="Stratégie de production"

# Créer un niveau d'accès
gcloud access-context-manager levels create CorpNetwork \
  --policy=accessPolicies/123456789 \
  --title="Réseau d'entreprise" \
  --basic-level-spec=access_level.yaml

# access_level.yaml
conditions:
  - ipSubnetworks:
    - 203.0.113.0/24  # Plage d'adresses IP de l'entreprise
  - members:
    - user:[email protected]

Créer un périmètre de service :

# Créer un périmètre
gcloud access-context-manager perimeters create production_perimeter \
  --policy=accessPolicies/123456789 \
  --title="Périmètre de production" \
  --resources=projects/123456789012 \
  --restricted-services=storage.googleapis.com,bigquery.googleapis.com \
  --access-levels=accessPolicies/123456789/accessLevels/CorpNetwork

# Ajouter un projet au périmètre
gcloud access-context-manager perimeters update production_perimeter \
  --policy=accessPolicies/123456789 \
  --add-resources=projects/987654321098

Règles d'entrée/sortie :

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

# Appliquer la règle d'entrée
gcloud access-context-manager perimeters update production_perimeter \
  --policy=accessPolicies/123456789 \
  --set-ingress-policies=ingress_rule.yaml

Règles de sortie :

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

# Appliquer la règle de sortie
gcloud access-context-manager perimeters update production_perimeter \
  --policy=accessPolicies/123456789 \
  --set-egress-policies=egress_rule.yaml

Services pris en charge :

Cloud Storage
BigQuery
Cloud SQL
Compute Engine
GKE
Cloud Functions
Et bien d'autres

Tests :

# Tester l'accès depuis l'intérieur du périmètre
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"Accès accordé : {len(blobs)} objets")
    except Exception as e:
        print(f"Accès refusé : {e}")

# Ceci réussira depuis un réseau autorisé
# Ceci échouera depuis un réseau non autorisé
test_access()

Surveillance :

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

Cas d'utilisation :

Empêcher l'exfiltration de données
Exigences de conformité (HIPAA, PCI-DSS)
Protéger les données sensibles
Isoler les environnements de production
Sécurité multi-locataire

Meilleures pratiques :

Commencer par le mode d'exécution à blanc
Tester minutieusement avant l'application
Utiliser des niveaux d'accès pour un contrôle précis
Surveiller les journaux VPC SC
Documenter les limites du périmètre
Examens d'accès réguliers

Rareté : Rare Difficulté : Difficile

Conclusion

Les entretiens avec les ingénieurs cloud GCP seniors nécessitent des connaissances techniques approfondies et une expérience pratique. Concentrez-vous sur :

Architecture : Haute disponibilité, évolutivité, reprise après sinistre
GKE : Orchestration de conteneurs, stratégies de déploiement
Sans serveur : Cas d'utilisation de Cloud Functions, Cloud Run
Mise en réseau : VPC partagé, connectivité hybride
Optimisation des coûts : Dimensionnement approprié, engagement d'utilisation, politiques de cycle de vie
Sécurité : IAM, chiffrement, contrôles VPC

Lorsque c'est possible, reliez votre réponse à un incident, une migration, une revue de coûts ou une amélioration de fiabilité que vous avez menée. C'est plus convaincant qu'une simple liste de services.

Conseils carrière récents

Questions d'entretien Senior GCP Cloud Engineer

Introduction

Architecture et conception

1. Concevez une application à haute disponibilité sur GCP.

Google Kubernetes Engine (GKE)

2. Comment déployez-vous et gérez-vous des applications sur GKE ?

Services sans serveur et avancés

3. Quand utiliseriez-vous Cloud Functions plutôt que Cloud Run ?

Mise en réseau avancée

4. Expliquez VPC partagé et quand l'utiliser.

Optimisation des coûts

5. Comment optimisez-vous les coûts GCP ?

Sécurité

6. Comment mettez-vous en œuvre les meilleures pratiques de sécurité dans GCP ?

Analyse des données

7. Comment concevez-vous et optimisez-vous BigQuery pour l'analyse à grande échelle ?

Services de base de données avancés

8. Quand utiliseriez-vous Cloud Spanner plutôt que Cloud SQL ?

Sécurité et conformité

9. Comment mettez-vous en œuvre les contrôles de service VPC ?

Conclusion

Conseils de carrière hebdomadaires qui fonctionnent vraiment

Conseils de carrière hebdomadaires qui fonctionnent vraiment

Articles Connexes

Questions d’entretien Senior Azure Cloud Engineer : guide par scénarios

Questions d’entretien Senior AWS Cloud Engineer

Questions d’entretien pour ingénieur sécurité senior

Démarquez-vous auprès des Recruteurs et Décrochez Votre Emploi de Rêve

Partager cet article

Réduisez Votre Temps de Rédaction de CV de 90%