Cloud

Premiers pas avec Google Cloud Platform #2

Dans cette deuxième partie, nous nous familiariserons avec l’utilitaire de ligne de commande Google Cloud (gcloud) et verrons comment nous pouvons gérer un ensemble de ressources GCP via cette CLI.

Gmkziz 👓

13 Dec 2024 • 14 min de lecture

Photo par Reza Rostampisheh / Unsplash

Utilisation de la documentation gcloud

gcloud -h
gcloud --help

# Get documentation about a specifig gcloud command group
gcloud help <group>
# or 
gcloud <group> --help

# Ex: get usage help for the gcloud 'config' command group
gcloud help config
# or
gcloud config --help

# Get documentation for a specific topic
gcloud topic <topic>

# Ex: get documentation about filtering gcloud commands outputs
gcloud topic filters
gcloud topic formats

Filtrage des sorties des commandes gcloud

# Get external IP of the VM named myvm:
gcloud compute instances list --filter=name:myvm --format='value(EXTERNAL_IP)')

# List firewall rules from the default VPC network that allows ICMP
gcloud compute firewall-rules list --filter="NETWORK:'default' AND ALLOW:'icmp'"`

# List compute images matching 'keyword' and limit output to 10
gcloud compute images list --filter="name ~ keyword" --limit 10`

Obtenir des informations sur le projet

# Get info about the project config (zone, region, project ID...)
gcloud config list [--all]

# Get other info about the project (quotas...)
gcloud compute project-info describe --project $(gcloud config get-value project)

Authentification et configuration du projet

# Login with a user account
gcloud auth login <user_email>

# Login as a service account
gcloud auth activate-service-account --key-file=<service_account_json_key_file>

# Set current project to work with

# Set default compute region and zone
gcloud config set compute/region $region
gcloud config set compute/zone $zone

# Show currently set region and zone values
gcloud config get-value compute/region
gcloud config get-value compute/zone

Attribution de rôles IAM

# Grant bigquery data viewer role to a service account
gcloud projects add-iam-policy-binding $GCP_PROJECT_ID \
    --member serviceAccount:${service_account_email} --role roles/bigquery.user 

# Grant bigquery user role to a service account
gcloud projects add-iam-policy-binding $GCP_PROJECT_ID \
    --member serviceAccount:${service_account_email} --role roles/bigquery.dataViewer

# Granting custom roles to service accounts
gcloud projects add-iam-policy-binding $GCP_PROJECT_ID \
    --member serviceAccount:${service_account_email} --role organizations/${ORGANIZATION_ID}/roles/${custom_role_name}

Gestion des rôles IAM

Obtenir des informations sur les rôles

# List predefined roles (don't specify the project ID)
gcloud iam roles list

# List custom roles
gcloud iam roles list --project $GCP_PROJECT_ID [--show-deleted]

# Get metadata about a specific role, including the role's permissions
gcloud iam roles describe $role_name

# List bigquery roles containing viewer in the name
gcloud iam list-grantable-roles //cloudresourcemanager.googleapis.com/projects/$GCP_PROJECT_ID --filter="name ~ bigquery viewer"

# List roles that can be applied for specific resources
gcloud iam list-grantable-roles //cloudresourcemanager.googleapis.com/projects/$GCP_PROJECT_ID

# List permissions that can be applied for specific resources
gcloud iam list-testable-permissions //cloudresourcemanager.googleapis.com/projects/$GCP_PROJECT_ID

Créer des rôles personnalisés

# Roles yaml file structure
# LAUNCH_STAGE could be ALPHA, BETA or GA
title: [ROLE_TITLE]
description: [ROLE_DESCRIPTION]
stage: [LAUNCH_STAGE]
includedPermissions:
- [PERMISSION_1]
- [PERMISSION_2]

# Create a custom role using a yaml file
gcloud iam roles create $role_name --project $GCP_PROJECT_ID \
  --file role-definition.yaml

# Create a custom role using gcloud only
gcloud iam roles create $role_name --project $GCP_PROJECT_ID \
    --title "Role title" --description "Role description" \
    --permissions compute.instances.get,compute.instances.list --stage ALPHA

Mise à jour des rôles personnalisés

# Update a custom role
# Create a Yaml file of the existing the role
gcloud iam roles describe $role_name --project $GCP_PROJECT_ID > role.yaml 

# Edit the role.yml file fields as needed (don't modify the etag)

# The etag ensures that the role we are updating has not already been
# updated by someone else

# For the role to be updated, the etag of the current role version 
# should match the one inside the Yaml file

# Each time a role is updated, the etag changes

# Update the role using the role.yml file
gcloud iam roles update $role_name --project $GCP_PROJECT_ID \
  --file role.yaml

# Update a custom role using gcloud only

# Add permissions
gcloud iam roles update $role_name --project $GCP_PROJECT_ID \
  --add-permissions storage.buckets.get,storage.buckets.list

# Remove permissions
gcloud iam roles update rolename --project $GCP_PROJECT_ID \
  --remove-permissions storage.buckets.list

Rendre les rôles personnalisés inutilisables

# Disable a custom role
gcloud iam roles update $role_name --project $GCP_PROJECT_ID --stage DISABLED

# Delete a custom role
gcloud iam roles delete $role_name --project $GCP_PROJECT_ID

# After that, role links are still present but disabled
# The role can still be restored within 7 days
# After the 7 days, permanent deletion process is launched and last 30 days
# The role ID will be available again after 37 days

# Restore custom roles (only within 7 days after the deletion)
gcloud iam roles undelete $role_name --project $GCP_PROJECT_ID

# Deleted roles will have the 'deleted: true' and 'stage: DISABLED'
# in their descriptions

Gestion des comptes de service

# Create a service account
gcloud iam service-accounts create $service_account_name

Gestion du réseau

VPC et sous-réseaux

# Create a VPC
# $subnet_mode can be:
# 'auto' for automatic subnets creation in all regions or 
# 'custom' for manual subnets creation
gcloud compute networks create $network_name --subnet-mode=$subnet_mode`

# Create a subnet
gcloud compute networks subnet create $subnet_name \
  --network=$network_name \
  --range=$subnet_range \
  --region=$subnet_region

# List, update, delete networks or subnets
gcloud compute networks [list|update|delete|--help] ...
gcloud compute networks subnet [list|update|delete|--help] ...

Règles de pare-feu

# Create a firewall rule
gcloud compute firewall-rules create $firewall_rule_name \
  --project=$gcp_project_id \
  --network=$network_name \
  --description="Description of the rule" \
  --direction=INGRESS \ # or EGRESS (for outbound traffic)
  --priority=1000 \ # rule priority, smallest priority are evaluated first
  --source-ranges=x.x.x.x/xx \ # multiple ranges separated by comma can be specified. Use 0.0.0.0/0 to match all adresses ranges
  --action=ALLOW \ # or DENY
  --rules=tcp:22,tcp:3389,icmp # comma separated list of protocols or protocol:port
  [--source-service-accounts] \ # identify the flow source by service accounts. Flow from/to computes using those service accounts will match
  [--source-tags] \ # identify the flow source by network tags. Flow from/to computes using those tags will match
  [--target-service-accounts] \ # identify the flow target by service accounts. Flow from/to computes using those service accounts will match
  [--target-tags] \ identify the flow target by network tags. Flow from/to computes using those tags will match

# List, update, delete firewall rules
gcloud compute firewall-rules [list|update|delete|--help] ...

# List default VPC firewall rules
gcloud compute firewall-rules list --filter="network='default'"
NAME: default-allow-icmp
NETWORK: default
DIRECTION: INGRESS
PRIORITY: 65534
ALLOW: icmp
DENY: 
DISABLED: False

NAME: default-allow-internal
NETWORK: default
DIRECTION: INGRESS
PRIORITY: 65534
ALLOW: tcp:0-65535,udp:0-65535,icmp
DENY: 
DISABLED: False

NAME: default-allow-rdp
NETWORK: default
DIRECTION: INGRESS
PRIORITY: 65534
ALLOW: tcp:3389
DENY: 
DISABLED: False

NAME: default-allow-ssh
NETWORK: default
DIRECTION: INGRESS
PRIORITY: 65534
ALLOW: tcp:22
DENY: 
DISABLED: False

Peering VPC entre le réseau-a (dans le projet-a) et le réseau-b (dans le projet-b)

Créez un peer-a-vers-b dans le peering de réseau VPC, dans le projet-a :
- sélectionnez le réseau-a comme source
- indiquer le réseau-b, dans le projet-b comme destination
- créer le peer-a-vers-b, l'état de peering sera en état d'attente
Créez un peer-b-vers-a dans le peering de réseau VPC, dans le projet-b :
- sélectionnez le réseau-b comme source
- indiquer le réseau-a, dans le projet-a comme destination
- créez le peer-b-vers-a, le statut de peering sera à l'état actif des deux côtés
Le peering est correctement configuré
Pour voir les nouvelles routes vers les VPC homologues :
- gcloud compute routes list --project $PROJECT_ID

Gestion des machines virtuelles

Par défaut :
- les instances de calcul obtiendront une IP publique
- le trafic réseau entrant est refusé
Pour plus d'informations sur les types de machines, consultez ressources-machines-gcp
Pour plus d'informations sur les régions et zones disponibles, consultez emplacements-des-centres-de-données-gcp

# Make sure a compute instance is ready:
gcloud compute instances get-serial-port-output $instance_name

# Set default compute region and zone to use
gcloud config set compute/region $region
gcloud config set compute/zone $zone

# Show currently set region and zone values
gcloud config get-value compute/region
gcloud config get-value compute/zone

# List public cloud compute instances images available for use
gcloud compute images list --filter="name ~ keyword" --limit 10`

# Get info about all command line options 
# for creating virtual machines
gcloud compute instances --help

# For quick creation commands examples, 
# search for 'EXAMPLES' in the help doc

# Create a virtual machine
$ gcloud compute instances create $instance_name \
--machine-type $instance_type \
--zone $zone \
--tags=$network-tags \
--image-family=debian-11 \
--image-project=debian-cloud \
--metadata=startup-script='#!/bin/bash
      apt-get update
      apt-get install mypackage -y
      another command here'

# SSH into a virtual machine
$ gcloud compute ssh $instance_name

Pour les machines Windows :
- Changer le disque de démarrage pour utiliser une image de machine Windows
- Définir les informations d'identification RDP (Remote Desktop Protocol) pour l'utilisateur « admin » :
```
gcloud compute reset-windows-password $instance_name --zone $zone --user admin
```
- Connectez-vous à la machine virtuelle Windows à l’aide de RDP :
  - Utilisez votre client RDP préféré en fonction de votre système d'exploitation
  - Si vous utilisez Windows, un client RDP est déjà installé :
    - Menu Démarrer => rechercher RDP
  - Si vous utilisez OSX, le package CoRD peut être utilisé
Pour gérer les machines virtuelles qui n'ont pas d'adresses IP publiques depuis l'extérieur du réseau interne de l'entreprise à l'aide de SSH et RDP, Cloud IAP (Identity Aware Proxy) peut être utilisé :

# Enable Cloud IAP API
gcloud services enable iap.googleapis.com

# Create VMs
gcloud compute instances create linux-iap --no-address
gcloud compute instances create windows-iap --image-project=windows-cloud --image=windows-server-2016-dc-v20240516 --no-address
gcloud compute instances create windows-connectivity --image-project=$project --image=$custom_image_name

# Create ingress firewall rules for IAP on port 22 (SSH) and 3389 (RDP)
# When --target-tags or --target-service-accounts are not specified, the rule 
# appplies to all instances using subnets of the network (VPC)
gcloud compute firewall-rules create allow-ingress-from-iap \
 --project=$project --network=$network_name \
--description="Allows SSH and RDP for IAP" \
--direction=INGRESS \
--priority=1000 \
--source-ranges=35.235.240.0/20 \
--action=ALLOW \
--rules=tcp:22,tcp:3389

# In the Google Cloud Console Identity-Aware Proxy configuration (search for IAP), switch to the SSH and TCP Resources tab. 
# Select the target instances and 'Add principal' for the VM service account or user account email that should connect to 
# the VMs using IAP, and grant them the Cloud IAP > IAP-Secured Tunnel User (iap.tunnelResourceAccessor)

# Start local tunnel to windows VM RDP port or linux SSH port
# The local tunneled port will be printed and can then be used
# to connect to the remote machine using RDP
gcloud compute start-iap-tunnel windows-machine 3389 --local-host-port=localhost:0 --zone=europe-west4-b
gcloud compute start-iap-tunnel linux-machine 22 --local-host-port=localhost:0  --zone=europe-west4-b

# The IAP Desktop software can also be used to connect to machines
https://github.com/GoogleCloudPlatform/iap-desktop

# or use this to directly ssh into 
# the linux machines through the iap tunnel
gcloud computes ssh --tunnel-through-iap $machine_name

Gestion des groupes d'instances + équilibreur de charge HTTP/HTTPS

Pour une analyse approfondie des équilibreurs de charge GCP, consultez : Comprendre les équilibreurs de charge GCP

instance-groups : can be used to manage a set of compute engine resources. Two types: gérés, et . Expose un port nommé qui peut ensuite être utilisé par les services backend des équilibreurs de charge pour cibler le groupe d'instances. Les équilibreurs de charge L7 externes/internes de GCP peuvent équilibrer la charge du trafic vers les ressources des groupes d'instances.
health-checks: utilisé par les équilibreurs de charge L7 externes/internes de GCP pour vérifier l'état des ressources des services back-end avant de leur envoyer du trafic. Différents types de vérifications comme tcp, http, http2, https, ssl, grpc peuvent être effectués, également sur un numéro de port personnalisé.
backend-service: utilisé par les équilibreurs de charge L7 externes/internes de GCP pour gérer les backends d'équilibrage de charge. Ces backends peuvent être des groupes d'instances, des groupes de points de terminaison réseau... Dans cette section, nous utiliserons un groupe d'instances comme backend d'un service backend. Nous spécifions le protocole de requête entrante à utiliser (peut varier en fonction du type d'équilibreur de charge), le nom du port pour le port nommé exporté des backends du groupe d'instances, le nom des tests de vie (health checks) à utiliser et le type de service backend comme global.
urls-maps: utilisé pour indiquer aux équilibreurs de charge L7 externes/internes de GCP où (sur quel service backend/stockage Cloud) rediriger une requête HTTP spécifique. Ex: rediriger https://example.com/video à un service backend et https://example.com/audio vers un autre service backend ou un service Cloud Storage.
target-http(s)-proxies: utilisé par les équilibreurs de charge L7 externes/internes de GCP. Met fin aux connexions HTTP ou HTTPS arrivant à l'équilibreur de charge et en crée de nouvelles vers les backends, provenant de l'équilibreur de charge. L'utilisation du proxy cible HTTPS (au lieu de HTTP) nécessite l'association de Certificats SSL/TLS pour chiffrer les communications entre les clients et l'équilibreur de charge.
forwarding-rules: l'interface des équilibreurs de charge GCP. Définit l'adresse IP de l'équilibreur de charge, un protocole + un ou plusieurs ports d'écoute et, selon le type d'équilibreur de charge, spécifie soit un Service de backendun target proxy ou un domaine target pool.

# Create instance template
gcloud compute instance-templates create $template_name \
   --region=us-east4 \
   --network=default \
   --subnet=default \
   --tags=allow-health-check \
   --machine-type=e2-medium \
   --image-family=debian-11 \
   --image-project=debian-cloud \
   [--metadata=startup-script-url=gs://BUCKET_NAME/FILE] \
   --metadata=startup-script='#!/bin/bash
     apt-get update
     apt-get install apache2 -y
     a2ensite default-ssl
     a2enmod ssl
     systemctl restart apache2'

# Create a Managed Instance Group
gcloud compute instance-groups managed create $instance_group_name --template=$template_name --size=2

# Another intance group creation command + autoscaling + named port
# --zones for multizones instance groups
# --zone for single zone instance groups

gcloud beta compute instance-groups managed create instance-group-1 --project=$project --base-instance-name=instance-group-1 --template=instance-template-1 --size=1 --zones=${region}-c --target-distribution-shape=EVEN --instance-redistribution-type=PROACTIVE --default-action-on-vm-failure=repair --no-force-update-on-repair --standby-policy-mode=manual --list-managed-instances-results=PAGELESS

gcloud beta compute instance-groups managed set-autoscaling instance-group-1 --project=$project --region=$region --mode=on --min-num-replicas=1 --max-num-replicas=5 --target-cpu-utilization=0.8 --cool-down-period=45
gcloud compute instance-groups set-named-ports instance-group-1 --project=$project --region=$region --named-ports=http:80

# Create firewall rule for health checks
gcloud compute firewall-rules create fw-allow-health-check \
  --network=default \
  --action=allow \
  --direction=ingress \
  --source-ranges=130.211.0.0/22,35.191.0.0/16 \
  --target-tags=allow-health-check \
  --rules=tcp:80

# Load balancer IP address
gcloud compute addresses create lb-ipv4-1 --ip-version=IPV4 --global
gcloud compute addresses describe lb-ipv4-1 --format="get(address)" --global

# Create health check
gcloud compute health-checks create http http-basic-check --port 80

# Create backend service
gcloud compute backend-services create web-backend-service --protocol=HTTP --port-name=http --health-checks=http-basic-check --global

# Add instance group as backend of the backend service
gcloud compute backend-services add-backend web-backend-service \
  --instance-group=lb-backend-group \
  --instance-group-zone=us-east4-c \
  --global

# Create URL map
gcloud compute url-maps create web-map-http --default-service web-backend-service

# Create target http proxy
gcloud compute target-http-proxies create http-lb-proxy --url-map web-map-http

# Create forwarding rule
gcloud compute forwarding-rules create http-content-rule \
   --address=lb-ipv4-1\
   --global \
   --target-http-proxy=http-lb-proxy \
   --ports=80

Gestion des équilibreurs de charge TCP

# Web server computes
# www1 and www2
$ gcloud compute instances create www1 \
    --zone=Zone  \
    --tags=network-lb-tag \
    --machine-type=e2-small \
    --image-family=debian-11 \
    --image-project=debian-cloud \
    --metadata=startup-script='#!/bin/bash
      apt-get update
      apt-get install apache2 -y
      service apache2 restart
      echo "
<h3>Web Server: www1</h3>" | tee /var/www/html/index.html'

# Computes firewall rule to allow TCP traffic on port 80
$ gcloud compute firewall-rules create www-firewall-network-lb \
    --target-tags network-lb-tag --allow tcp:80

# LB external IP
$ gcloud compute addresses create network-lb-ip-1 --region Region

# Example for reserved private address from a specific subnet
$ gcloud compute addresses create my-ilb-ip --subnet=SUBNET --region Region --addresses=ADDRESS

# Health check resource
$ gcloud compute http-health-checks create basic-check

# Example for TCP health check
$ gcloud compute health-checks create tcp my-ilb-health-check --port=80 --port-name=http --region=$region

# Target pool (to have virtual machines as backend)
$ gcloud compute target-pools create www-pool \
  --region Region --http-health-check basic-check

# Add computes to target pool
$ gcloud compute target-pools add-instances www-pool \
    --instances www1,www2

# Instead of target pools, we can use backend services 
# to add instance groups as backends instead of virtual machines

# Create backend service
$ gcloud compute backend-services create my-backend-service \
  --region=$region --health-checks=my-ilb-health-check --health-checks-region=$region --load-balancing-scheme=INTERNAL

# Add instance groups to backend service
$ gcloud compute backend-services add-backend my-backend-service \
    --instance-group=my-instance-group \
    --instance-group-region=$region

# Forwarding rule (to target pool: VMs backend)
$ gcloud compute forwarding-rules create www-rule \
    --region Region \
    --ports 80 \
    --address network-lb-ip-1 \
    --target-pool www-pool

# Forwarding rule (to backend services: instance groups as backend)
$ gcloud compute forwarding-rules create www-rule \
    --ports=80 \
    --address=my-ilb-ip \
    --backend-service=my-backend-service \
    --address-region=$region \
    --load-balancing-scheme=INTERNAL \
    --network=my-internal-app \
    --subnet=subnet-b

# Get LB IP to reach VMs
$ IPADDRESS=$(gcloud compute forwarding-rules describe www-rule --region Region --format="json" | jq -r .IPAddress)

# Note:

# the name of the Load balancer in GCP is the name of the target pool or backend service
# the forwarding rule IP address makes the LB private or public
# by default (without specifying options to make the backend service and the forwarding rule load balancing scheme INTERNAL), the LB will be public

Gestion des buckets Cloud Storage (GCS)

# Create a GCS bucket
gsutil mb -p [PROJECT_ID] gs://$bucket_name

# List bucket content
gsutil ls [-l] gs://$bucket_name

# Copy a file to a GCS bucket
gsutil cp myfile gs://$bucket_name

# Download files from a GCS bucket
gsutil cp -r gs://$bucket_name/myfile $destination_path

# Make GCS buckets objects publicly accessible
gsutil acl ch -u AllUsers:R gs://$bucket_name/myfile

# Remove public access on a GCS buckets objects
gsutil acl ch -d AllUsers gs://$bucket_name/myfile

# Remove files from a GCS bucket
gsutil rm gs://$bucket_name/myfile

Gestion des conteneurs

Cluster standard GKE (VPC natif + nœuds privés)

Une plage d'adresses CIDR /28 doit être spécifiée lors de la création d'un cluster GKE privé pour le plan de contrôle / les nœuds maîtres
L'Alias d'IP doit également être activé afin que les machines des nœuds utilisent plusieurs adresses IP pour différents services sur la même machine
Après la création du cluster, un pool de nœuds par défaut est automatiquement créé avec 3 nœuds

# Create cluster (automatic network + subnets creation)
gcloud beta container clusters create private-cluster \
    --enable-private-nodes \
    --master-ipv4-cidr 172.16.0.16/28 \
    --enable-ip-alias \
    --create-subnetwork ""

# See created network + subnets used by the GKE cluster
# Look for gke-private-cluster-subnet-xxxxxxxx
gcloud compute networks subnets list --network default

# See details about the subnet
# You should see a primary IP address range (used for nodes and loadbalancers)
# and two secondary IP addresses ranges (one for pods, one for services)
gcloud compute networks subnets describe [SUBNET_NAME] --region=$REGION

# The GKE cluster API server will have a public endpoint
# that is by default not widely accessible
# To allows IP address to communicate with the endpoint:
gcloud container clusters update private-cluster \
    --enable-master-authorized-networks \
    --master-authorized-networks [MY__EXTERNAL_RANGE]

# Create a network for a GKE cluster
gcloud compute networks subnets create my-subnet \
    --network default \
    --range 10.0.4.0/22 \
    --enable-private-ip-google-access \
    --region=$REGION \
    --secondary-range my-svc-range=10.0.32.0/20,my-pod-range=10.4.0.0/14 # Optional could be created automatically when creating a cluster using this subnet

# Create a GKE cluster using the preceding network
gcloud beta container clusters create private-cluster2 \
    --enable-private-nodes \
    --enable-ip-alias \
    --master-ipv4-cidr 172.16.0.32/28 \
    --subnetwork my-subnet \
    --network=default \
    --services-secondary-range-name my-svc-range \ # Optional, will be created automatically if not set
    --cluster-secondary-range-name my-pod-range \ # Optional, will be created automatically if not set
    --zone=$ZONE # for zonal clusters
    [--service-account=sa-email] # service account that will be attached to the cluster nodes
    [--enable-private-endpoint] # Make sure only private endpoint is available for cluster API server
    [--num-nodes] # Number of nodes
    [--scopes] # Oauth scopes

# Connection to cluster with kubectl
sudo apt-get install kubectl
sudo apt-get install google-cloud-sdk-gke-gcloud-auth-plugin

# Create kubectl config/credentials to talk to the cluster using kubectl
# Will use the cluster public endpoint by default
# use --internal-ip to use the private API endpoint in the config
gcloud container clusters get-credentials clustername --zone=$ZONE

Gestion des fonctions Cloud

Tutoriel sur la rédaction de fonctions Google Cloud | Architecture de Google Pub/Sub

Il existe deux types de fonctions Cloud :

Fonctions HTTP déclenchées par une requête HTTP
Fonctions basées sur des événements déclenchées à partir d'événements provenant d'autres services GCP tels que les buckets Cloud Storage, Pub/Sub...

Activer les API Cloud Functions

# Enable Cloud function APIs
gcloud services enable \
  artifactregistry.googleapis.com \
  cloudfunctions.googleapis.com \
  cloudbuild.googleapis.com \
  eventarc.googleapis.com \
  run.googleapis.com \
  logging.googleapis.com \
  storage.googleapis.com \
  pubsub.googleapis.com

Créer une fonction gen2 basée sur un événement de bucket GCS

Les fonctions de Cloud Storage sont basées sur les notifications Pub/Sub de Cloud Storage et prennent en charge les types d'événements de finalisation (finalize), de suppression (delete), d'archivage (archive) et de mise à jour des métadonnées (metadata).
Nous devons attribuer le rôle d'éditeur Pub/Sub à l'agent de service Cloud Storage sur notre projet. Un agent de service est un compte de service géré par Google qui permet au service d'accéder à nos ressources

SERVICE_ACCOUNT=$(gcloud storage service-agent)
gcloud projects add-iam-policy-binding $PROJECT_ID --member serviceAccount:$SERVICE_ACCOUNT --role roles/pubsub.publisher

Création de fonction

# The function index.js

const functions = require('@google-cloud/functions-framework');

// Register a CloudEvent callback with the Functions Framework that will
// be triggered by Cloud Storage events.
functions.cloudEvent('checkTempData', cloudEvent => {
  console.log(`Event ID: ${cloudEvent.id}`);
  console.log(`Event Type: ${cloudEvent.type}`);

  const file = cloudEvent.data;
  console.log(`Bucket: ${file.bucket}`);
  console.log(`File: ${file.name}`);
  console.log(`Created: ${file.timeCreated}`);
});

# The function dependencies file

{
  "name": "temperature-data-checker",
  "version": "0.0.1",
  "main": "index.js",
  "dependencies": {
    "@google-cloud/functions-framework": "^2.1.0"
  }
}

# Cloud function creation

gcloud functions deploy temperature-data-checker \
 --gen2 \
 --runtime nodejs20 \
 --entry-point checkTempData \ # name of the main function inside the index.js file
 --source . \
 --region $REGION \
 --trigger-bucket $BUCKET \
 --trigger-location $BUCKET_REGION \
 --max-instances 1

 # you may got permissions error at firsts launchs. Just retry

Créer une fonction basée sur un événement Pub/Sub

# Function named helloWorld
# function code resides inside the functionbucket bucket
# function will be triggered once a message is published 
# inside the hello_world Pub/Sub topic
# function code will be run with nodejs20
gcloud functions deploy helloWorld \
  --stage-bucket functionbucket \
  --trigger-topic hello_world \
  --runtime nodejs20

# if you get an "OperationError" message, just rerun the command

Inspecter les fonctions

# Get details about the deployed function
gcloud functions describe helloWorld

# Show function logs
gcloud functions logs read helloWorld

gcloud functions logs read gen_function \
 --region $REGION --gen2 --limit=100 --format "value(log)"

Gestion des journaux

Voir Présentation de la journalisation GCP pour plus d'informations.

# See buckets used for storing logs of a project
gcloud logging buckets list

# List logs containers for a project
gcloud logging logs list

# Reading logs from any logs containers
gcloud logging read "LOG_FILTER"

# Exemples:

# Show activity logs for a specific pod (creation, deletion...)
gcloud logging read 'protoPayload.resourceName:mypod AND protoPayload.resourceNamespace:mynamespace AND logName:projects/mygcpproject/logs/cloudaudit.googleapis.com%2Factivity AND timestamp>="2024-05-14T06:05:54.238629139Z" AND timestamp<="2024-05-14T13:16:54.238629139Z"' --limit 1