Atelier pratique — ADP Google Cloud Associate Data Practitioner

Présentation

Prérequis

Étapes

1. 1.Fournisseur, services du projet, nommage

   Activez Cloud Storage, BigQuery et BigQuery Data Transfer Service (qui alimente les requêtes planifiées).

   Copier

   terraform {
     required_version = ">= 1.5"
   
     required_providers {
       google = { source = "hashicorp/google", version = "~> 6.0" }
     }
   }
   
   provider "google" {
     project = "your-project-id" # REPLACE
     region  = "us-central1"
   }
   
   locals {
     labels = {
       project    = "certlabpro-adp"
       managed_by = "terraform"
     }
   }
   
   resource "google_project_service" "storage" {
     service            = "storage.googleapis.com"
     disable_on_destroy = false
   }
   
   resource "google_project_service" "bigquery" {
     service            = "bigquery.googleapis.com"
     disable_on_destroy = false
   }
   
   resource "google_project_service" "bqdts" {
     service            = "bigquerydatatransfer.googleapis.com"
     disable_on_destroy = false
   }

2. 2.Provisionner un bucket de destination Cloud Storage pour les données brutes

   Déploie :

   • Cloud Storage

   Chaque pipeline de données de type ADP commence par un bucket de destination — les fichiers bruts (CSV / JSON / Parquet / Avro) y sont déposés, les jobs en aval les lisent. Le bucket est la limite entre l'extérieur du lac et l'intérieur du lac. L'examen ADP teste ici le choix de la classe de stockage — Standard pour le niveau de destination (lectures fréquentes dans les 30 premiers jours), avec une règle de cycle de vie passant à Coldline après 90 jours.

   L'accès uniforme au niveau du bucket est activé (le défaut de sécurité recommandé par ADP).

   Copier

   resource "random_id" "suffix" {
     byte_length = 4
   }
   
   resource "google_storage_bucket" "landing" {
     name                        = "certlabpro-adp-landing-${random_id.suffix.hex}"
     location                    = "US"
     uniform_bucket_level_access = true
     force_destroy               = true # lab-only
   
     lifecycle_rule {
       condition {
         age = 90
       }
       action {
         type          = "SetStorageClass"
         storage_class = "COLDLINE"
       }
     }
   
     labels = local.labels
   
     depends_on = [google_project_service.storage]
   }

3. 3.Créer un ensemble de données BigQuery + une table partitionnée par heure d'ingestion

   Déploie :

   • BigQuery

   BigQuery est l'entrepôt de données sans serveur de GCP — paiement à l'octet scanné pour les requêtes, paiement à l'octet stocké pour les données. L'examen ADP teste le partitionnement + le regroupement comme leviers de contrôle des coûts : les tables partitionnées permettent aux requêtes d'ignorer les données non pertinentes ; les tables regroupées (clustered) placent les lignes associées ensemble dans le stockage.

   Nous créons :

   1. Un ensemble de données analytics — le conteneur BigQuery (l'équivalent GCP d'un schéma / d'une base de données). Définissez delete_contents_on_destroy = true pour faciliter le nettoyage du labo.
   2. Une table events avec partitionnement par heure d'ingestion (pseudo-colonne _PARTITIONTIME) et expiration de partition après 30 jours. Les tables de production partitionnent généralement par une colonne (time_partitioning.field) pour la sélectivité des requêtes.
   Copier

   resource "google_bigquery_dataset" "analytics" {
     dataset_id                  = "analytics"
     location                    = "US"
     delete_contents_on_destroy  = true # lab-only
   
     labels = local.labels
   
     depends_on = [google_project_service.bigquery]
   }
   
   resource "google_bigquery_table" "events" {
     dataset_id          = google_bigquery_dataset.analytics.dataset_id
     table_id            = "events"
     deletion_protection = false # lab-only
   
     time_partitioning {
       type                     = "DAY"
       expiration_ms            = 30 * 24 * 60 * 60 * 1000 # 30 days
       require_partition_filter = true
     }
   
     schema = jsonencode([
       { name = "event_id",    type = "STRING",    mode = "REQUIRED" },
       { name = "event_type",  type = "STRING",    mode = "REQUIRED" },
       { name = "event_time",  type = "TIMESTAMP", mode = "REQUIRED" },
       { name = "user_id",     type = "STRING",    mode = "NULLABLE" },
       { name = "payload",     type = "JSON",      mode = "NULLABLE" },
     ])
   
     labels = local.labels
   }

4. 4.Planifier une requête BigQuery qui s'exécute toutes les heures

   Déploie :

   • BigQuery

   Les requêtes planifiées sont le principe primitif du modèle ADP pour l'ingestion d'un ensemble de données BigQuery vers un autre à une cadence fixe. Elles s'exécutent sur l'infrastructure BigQuery Data Transfer Service (séparée des requêtes ad-hoc bq) et sont facturées au même tarif par octet scanné.

   Nous planifions une requête qui s'exécute toutes les heures, lit à partir de l'ensemble de données public bigquery-public-data.samples.shakespeare et écrit dans la table events de l'étape 3. La forme MERGE (upsert) est la réponse canonique d'ADP pour l'ingestion idempotente — réexécuter la même heure n'insère pas deux fois.

   La requête planifiée s'exécute en tant que compte de service par défaut du projet ; les déploiements de production utilisent un compte de service de transfert dédié avec roles/bigquery.dataEditor sur la destination.

   Copier

   resource "google_bigquery_data_transfer_config" "hourly_load" {
     display_name           = "certlabpro-adp-hourly-load"
     data_source_id         = "scheduled_query"
     location               = "US"
     schedule               = "every 1 hours"
     destination_dataset_id = google_bigquery_dataset.analytics.dataset_id
   
     params = {
       query = "INSERT INTO `${google_bigquery_dataset.analytics.dataset_id}.${google_bigquery_table.events.table_id}` (event_id, event_type, event_time, user_id, payload) SELECT GENERATE_UUID() AS event_id, \"shakespeare-line\" AS event_type, CURRENT_TIMESTAMP() AS event_time, NULL AS user_id, TO_JSON(STRUCT(word, word_count, corpus)) AS payload FROM `bigquery-public-data.samples.shakespeare` WHERE word_count > 100 LIMIT 100"
     }
   
     depends_on = [
       google_project_service.bqdts,
       google_bigquery_table.events,
     ]
   }

Nettoyage