Google Cloud Platform

Cloud Storage

Prix de stockage :

Taille des données	1 Go	500 Go	1 To	50 To
Standard	0.017	8.607	17.628	881.408
Nearline	0.009	4.304	8.814	440.704
ColdLine	0.003	1.721	3.526	176.282
Archive	0.001	0.516	1.058	52.884

Prix de récupération des données :

Taille des données	1 Go	500 Go	1 To	50 To
Standard	0	0	0	0
Nearline	0,01	5	10.24	512
ColdLine	0.02	10	20.48	1024
Archive	0,05	25	51.2	2560

Durée minimale de stockage :

Type de stockage	Durée minimale de stockage
Standard	0
Nearline	30 jours
ColdLine	90 jours
Archive	180 jours

Attention ! Des frais supplémentaires vous seront facturés en cas d'altération des données stockés dans les types de stockage soumis à une durée minimale de stockage. Par exemple, si je supprime au bout d'un mois un fichier (de cinquante gigas) de type Archive, j'aurai 5 mois de pénalités. Ce qui fera un total de 0.3$ (5*30*50*0.00004) de pénalités pour avoir supprimé ce fichier trop tôt !

Cloud Load Balancing :.

Le tableau ci-dessous use de la statistique provenant de cette source qui affirme que de nos jour, une page internet pèse en moyenne 2.3 Mo.

Ce tableau détermine le prix de Google Cloud Balancing en fonction des utilisateur par mois :

Utilisateurs	1 page	10 pages	50 pages	100 pages
1	0,00000184	0,0000184	0,000092	0,000184
10	0,0000184	0,000184	0,00092	0,00184
100	0,000184	0,00184	0,0092	0,0184
1 000	0,00184	0,0184	0,092	0,184
10 000	0,0184	0,184	0,92	1,84
100 000	0,184	1,84	9,2	18,4
1 000 000	1,84	18,4	92	184
10 000 000	18,4	184	920	1840

Prix du cloud load balancer seul :

Nombre de jour par mois * heures par jour * Prix par heure = 31 * 24 * 0,025 = 18.6 $

Prix de transfert de données par Mo = 0.000008 $

Ce tableau détermine le prix de Google Cloud Balancing en fonction des utilisateur par mois avec le prix du load balancer :

Utilisateurs	1 page	10 pages	50 pages	100 pages
1	18,60000184	18,6000184	18,600092	18,600184
10	18,6000184	18,600184	18,60092	18,60184
100	18,600184	18,60184	18,6092	18,6184
1 000	18,60184	18,6184	18,692	18,784
10 000	18,6184	18,784	19,52	20,44
100 000	18,784	20,44	27,8	37
1 000 000	20,44	37	110,6	202,6
10 000 000	37	202,6	938,6	1858,6

IP Pricing :

Faire un choix d'hébergement :

Network Pricing :

Réductions liées à l'utilisation de vos VM :

Récapitulatif des service de stockage et des bases de données

Schémas décisionnel :

Google Cloud Shell :

Cloud shell provides the following:

Temporary Compute Engine VM
Command-line access to the instance via a browser
5 GB of persistent disk storage ($HOME dir)
Pre-installed Cloud SDK and other tools
gcloud: for working with Compute Engine and many Google Cloud services
gsutil: for working with Cloud Storage
kubectl: for working with Google Kubernetes Engine and Kubernetes
bq: for working with BigQuery
Language support for Java, Go, Python, Node.js, PHP, and Ruby
Web preview functionality
Built-in authorization for access to resources and instances

Définir des variables :

export PROJECT_ID=XXXXXXXX
export ZONE=us-central1-a

Quelques notes :

LINUX :

Voici un exemple de clé RSA à entrer dans Google Cloud pour, par exemple, utiliser PUTTY sur une VM Compute Engine dans Google Cloud.

ssh-rsa AAAAB3NzaC1yc2EAAAABJQAAAQEAnD6qhcMV+JPyHIeU4817qk2F5I5HeK8JcjzWsIdCx925QZ1bZ7o8Peo3AuDYTitk0gFiLmfaJrKr3Gtt1731CsFDbOLkA/mwfdAXk9zpuEviIaODy9pOVLGmqMafsQFeETEzTxUrbkkaGqL1ELJy0OYTy+FVsRzKWQdpnbC7DptKnLDaVsuO3TQBjOnNJk1EeXIs6LlxxRb4gQE7z+onyjIDqoscC4K/9sOdzoqk/V/ZfUVNha1K+ePMp3pcF27ikRslhHUK384X/akrPXAmJ58S5pun54XeRAAqENrsGBX/qO4lxmd9NzDgbhtqSj3DOzM3K4gI5hJva1EYrN39hQ== nehemie

Windows :

Activer le compte Administrateur :

Si vous souhaitez déployer le rôle ADDS sur un Windows Serveur dans Google Cloud, vous devez procéder aux étapes ci-dessous :

net user Administrator /passwordreq:yes
net user Administrator *
net user Administrator /active:yes

Afficher les zones :

gcloud compute zones list | grep us-central1

Créer une instance de VM :

gcloud compute instances create VM1 --machine-type n1-standard-2 --zone $ZONE --project $PROJECT_ID
gcloud compute instances describe VM1 --zone $ZONE --project $PROJECT_ID
gcloud compute ssh VM1 --zone $ZONE --project $PROJECT_ID

Créer un cluster :

gcloud container clusters create mon-cluster --project $PROJECT_ID
gcloud container clusters get-credentials mon-cluster --project $PROJECT_ID
kubectl create deployment hello-server --image=gcr.io/google-samples/hello-app:1.0
kubectl expose deployment hello-server --type=LoadBalancer --port 8080

Supprimer un cluster :

gcloud container clusters delete mon-cluster --project $PROJECT_ID

Équilibrage de charge HTTP et Réseau :

gcloud config set project IDPROJET

gcloud config set compute/zone us-central1-a
gcloud config set compute/region us-central1

gcloud compute instances create www1 \
  --image-family debian-9 \
  --image-project debian-cloud \
  --zone us-central1-a \
  --tags network-lb-tag \
  --metadata startup-script="#! /bin/bash
    sudo apt-get update
    sudo apt-get install apache2 -y
    sudo service apache2 restart
    echo '<!doctype html><html><body><h1>www1</h1></body></html>' | tee /var/www/html/index.html"


gcloud compute instances create www2 \
  --image-family debian-9 \
  --image-project debian-cloud \
  --zone us-central1-a \
  --tags network-lb-tag \
  --metadata startup-script="#! /bin/bash
    sudo apt-get update
    sudo apt-get install apache2 -y
    sudo service apache2 restart
    echo '<!doctype html><html><body><h1>www2</h1></body></html>' | tee /var/www/html/index.html"

gcloud compute instances create www3 \
  --image-family debian-9 \
  --image-project debian-cloud \
  --zone us-central1-a \
  --tags network-lb-tag \
  --metadata startup-script="#! /bin/bash
    sudo apt-get update
    sudo apt-get install apache2 -y
    sudo service apache2 restart
    echo '<!doctype html><html><body><h1>www3</h1></body></html>' | tee /var/www/html/index.html"




Règle de parefeu pour autorisé le trafique entrant :
gcloud compute firewall-rules create www-firewall-network-lb \
    --target-tags network-lb-tag --allow tcp:80




Afficher les instances :
gcloud compute instances list

www1 : 34.133.245.113
www2 : 104.154.73.144
www3 : 34.71.227.111

Vérification du bon fonctionnement :
curl 34.133.245.113
curl 104.154.73.144
curl 34.71.227.111


Tâche 3 : Configurer le service d'équilibrage de charge

Création d'une adresse IP Externe pour l'équilibrage ::
gcloud compute addresses create network-lb-ip-1 \
 --region us-central1


Ajout d'une ancienne ressource :
gcloud compute http-health-checks create basic-check

Ajout du pool cible :

gcloud compute target-pools create www-pool \
    --region us-central1 --http-health-check basic-check



Ajoutez les instances au pool :

gcloud compute target-pools add-instances www-pool \
    --instances www1,www2,www3

Ajout d'une règle de transfet :
gcloud compute forwarding-rules create www-rule \
    --region us-central1 \
    --ports 80 \
    --address network-lb-ip-1 \
    --target-pool www-pool


Saisissez la commande suivante pour afficher l'adresse IP externe définie dans la règle de transfert www-rule utilisée par l'équilibreur de charge :
gcloud compute forwarding-rules describe www-rule --region us-central1


while true; do curl -m1 35.225.251.108; done



Tâche 5 : Créer un équilibreur de charge HTTP

gcloud compute instance-templates create lb-backend-template \
   --region=us-central1 \
   --network=default \
   --subnet=default \
   --tags=allow-health-check \
   --image-family=debian-9 \
   --image-project=debian-cloud \
   --metadata=startup-script='#! /bin/bash
     apt-get update
     apt-get install apache2 -y
     a2ensite default-ssl
     a2enmod ssl
     vm_hostname="$(curl -H "Metadata-Flavor:Google" \
     http://169.254.169.254/computeMetadata/v1/instance/name)"
     echo "Page served from: $vm_hostname" | \
     tee /var/www/html/index.html
     systemctl restart apache2'


Commencez par créer le modèle de l'équilibreur de charge :
gcloud compute instance-groups managed create lb-backend-group \
   --template=lb-backend-template --size=2 --zone=us-central1-a

Créez la règle de pare-feu fw-allow-health-check. Il s'agit d'une règle d'entrée qui autorise le trafic provenant des systèmes de vérification d'état Google Cloud (130.211.0.0/22 et 35.191.0.0/16). Cet exemple utilise le tag cible allow-health-check pour identifier les VM.
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


Maintenant que vos instances sont opérationnelles, configurez une adresse IP externe statique globale que vos clients utiliseront pour accéder à votre équilibreur de charge.
gcloud compute addresses create lb-ipv4-1 \
    --ip-version=IPV4 \
    --global

Savoir quelle adresse :
gcloud compute addresses describe lb-ipv4-1 \
    --format="get(address)" \
    --global

= 34.117.115.143
Créez une vérification d'état pour l'équilibreur de charge :

    gcloud compute health-checks create http http-basic-check \
        --port 80
Créer un service de backend :
    gcloud compute backend-services create web-backend-service \
        --protocol=HTTP \
        --port-name=http \
        --health-checks=http-basic-check \
        --global


Ajoutez votre groupe d'instances en tant que backend au service de backend :
    gcloud compute backend-services add-backend web-backend-service \
        --instance-group=lb-backend-group \
        --instance-group-zone=us-central1-a \
        --global


Créez un mappage d'URL pour acheminer les requêtes entrantes vers le service de backend par défaut :
    gcloud compute url-maps create web-map-http \
        --default-service web-backend-service

Créez un proxy HTTP cible, qui va acheminer les requêtes vers votre mappage d'URL :
    gcloud compute target-http-proxies create http-lb-proxy \
        --url-map web-map-http


Créez une règle de transfert globale pour acheminer les requêtes entrantes vers le proxy :
    gcloud compute forwarding-rules create http-content-rule \
        --address=lb-ipv4-1\
        --global \
        --target-http-proxy=http-lb-proxy \
        --ports=80

Google Kubernetes Engine :

Définition de la zone de préférence GCP (Google Cloud Project) :

export MY_ZONE=us-central1-a

Création d'un cluster avec deux noeuds :

gcloud container clusters create webfrontend --zone $MY_ZONE --num-nodes 2

Déploiement d'une image :

kubectl create deploy nginx --image=nginx:1.17.10

Exposition du service :

kubectl expose deployment nginx --port 80 --type LoadBalancer

Définition des nombre de PODs qui s'exécutent sur le service :

kubectl scale deployment nginx --replicas 3

Deployment Manager and Stackdriver :

Deployment Manager = Création d'un déploiement et maintien de celui-ci

Stackdriver = Monitoring

Créer un déploiement :

Fichier mydeploy.yml

resources:
- name: my-vm
  type: compute.v1.instance
  properties:
    zone: us-central1-a
    machineType: zones/us-central1-a/machineTypes/n1-standard-1
    metadata:
      items:
      - key: startup-script
        value: "apt-get update; apt-get install nginx-light -y"
    disks:
    - deviceName: boot
      type: PERSISTENT
      boot: true
      autoDelete: true
      initializeParams:
        sourceImage: https://www.googleapis.com/compute/v1/projects/debian-cloud/global/images/debian-9-stretch-v20201216
    networkInterfaces:
    - network: global/networks/default

Lancer le déploiement :

gcloud deployment-manager deployments create my-first-depl --config mydeploy.yaml

Mettre à jour un déploiement :

gcloud deployment-manager deployments update my-first-depl --config mydeploy.yaml

Stackdriver :

Eteindre la machine virtuelle, définir Allow full access to all Cloud APIs dans le menu Édition de celle-ci en utilisant le Service account dropdown. Puis rallumer la machine.

Installation des agents sur la machine :

curl -sSO https://dl.google.com/cloudagents/install-monitoring-agent.sh
sudo bash install-monitoring-agent.sh

curl -sSO https://dl.google.com/cloudagents/install-logging-agent.sh
sudo bash install-logging-agent.sh

Créer un IAM Service Account :

UN IAM Service Accout est un compte créé dans Google Cloud pour spécifier des droits très précits. Par exemple, cela nous permet d'autoriser une machine virtuelle à uploder des images dans notre bucket. Celle-ci aura uniquement la permission d'upload sur le bucket.

Création de L'IAM service Account :

Se rendre dans AM & admin > Service accounts
Cliquer sur Create service account.
Lui donner un nom
Définir les autorisations voulues
Finaliser la création
Se rendre dans le menu "Key"
Faire Add key
Sélectionner une Key Json
Puis une clef sera automatiquement télécharger, vous la renommerez "credentials.json".

Utiliser le service accourt depuis un VM :

Se connecter en SSH à la VM
Uploader le fichier "credentials.json"
Puis réaliser la commande ci-dessous :

gcloud auth activate-service-account --key-file credentials.json

Cloud SQL :

Choisir Cloud SQL :

Décider quel mode d'interconnexion choisir :

Shared VPC contre VPC peering :

SHARED VPC : Un VPC partagé permet à une organisation de connecter des ressources provenant de différents projets à un réseau cloud privé virtuel (VPC) commun, afin que ces ressources puissent communiquer entre elles de manière sécurisée et efficace en utilisant les adresses IP internes de ce réseau.

PEERING VPC : L'appairage de réseaux VPC vous permet de connecter des réseaux VPC afin que les charges de travail de différents réseaux VPC puissent communiquer en interne. Le trafic reste à l'intérieur du réseau de Google et ne traverse pas l'Internet public.

Choisir un type de load balancing :

Information : Un équilibreur de charge répartit le trafic des utilisateurs entre plusieurs instances de vos applications. En répartissant la charge, l'équilibrage de charge réduit le risque que vos applications rencontrent des problèmes de performances.

Procéder à un déploiement automatique avec deployment-manager :

nano instance-template.jinja

resources:
- name: {{ env["name"] }}
  type: compute.v1.instance  
  properties:
     machineType: zones/{{ properties["zone"] }}/machineTypes/{{ properties["machineType"] }}
     zone: {{ properties["zone"] }}
     networkInterfaces:
      - network: {{ properties["network"] }}
        subnetwork: {{ properties["subnetwork"] }}
        accessConfigs:
        - name: External NAT
          type: ONE_TO_ONE_NAT
     disks:
      - deviceName: {{ env["name"] }}
        type: PERSISTENT
        boot: true
        autoDelete: true
        initializeParams:
          sourceImage: https://www.googleapis.com/compute/v1/projects/debian-cloud/global/images/family/debian-9

nano config.yaml

    imports:
    - path: instance-template.jinja

    resources:
    # Create the auto-mode network
    - name: mynetwork
      type: compute.v1.network
      properties:
        autoCreateSubnetworks: true

    # Create the firewall rule
    - name: mynetwork-allow-http-ssh-rdp-icmp
      type: compute.v1.firewall
      properties:
        network: $(ref.mynetwork.selfLink)
        sourceRanges: ["0.0.0.0/0"]
        allowed:
        - IPProtocol: TCP
          ports: [22, 80, 3389]
        - IPProtocol: ICMP

     # Create the mynet-us-vm instance
    - name: mynet-us-vm
      type: instance-template.jinja
      properties:
        zone: us-central1-a
        machineType: n1-standard-1
        network: $(ref.mynetwork.selfLink)
        subnetwork: regions/us-central1/subnetworks/mynetwork

    # Create the mynet-eu-vm instance
    - name: mynet-eu-vm
      type: instance-template.jinja
      properties:
        zone: europe-west1-d
        machineType: n1-standard-1
        network: $(ref.mynetwork.selfLink)  
        subnetwork: regions/europe-west1/subnetworks/mynetwork

Préparation au déploiement :

gcloud deployment-manager deployments create dminfra --config=config.yaml --preview

Déploiement :

gcloud deployment-manager deployments update dminfra

Procéder à un déploiement automatique avec Terraform :

Création du dossier pour la configuration :

mkdir tfinfra ; cd tfinfra

Définition du provider :

nano provider.tf

provider "google" {}

Définition du réseau à créer :

nano mynetwork.tf

# Create the mynetwork network
resource "google_compute_network" "mynetwork" {
  name                    = "mynetwork"
  auto_create_subnetworks = true
}

# Add a firewall rule to allow HTTP, SSH, RDP, and ICMP traffic on mynetwork
resource "google_compute_firewall" "mynetwork-allow-http-ssh-rdp-icmp" {
  name    = "mynetwork-allow-http-ssh-rdp-icmp"
  network = google_compute_network.mynetwork.self_link

  allow {
    protocol = "tcp"
    ports    = ["22", "80", "3389"]
  }
  allow {
    protocol = "icmp"
  }
  source_ranges = ["0.0.0.0/0"]
}

# Create the mynet-us-vm instance
module "mynet-us-vm" {
  source           = "./instance"
  instance_name    = "mynet-us-vm"
  instance_zone    = "us-central1-a"
  instance_network = google_compute_network.mynetwork.self_link
}

# Create the mynet-eu-vm" instance
module "mynet-eu-vm" {
  source           = "./instance"
  instance_name    = "mynet-eu-vm"
  instance_zone    = "europe-west1-d"
  instance_network = google_compute_network.mynetwork.self_link
}

Définition de l'instance à créer :

nano instances/main.tf

variable "instance_name" {}
variable "instance_zone" {}
variable "instance_type" {
  default = "n1-standard-1"
  }
variable "instance_network" {}

resource "google_compute_instance" "vm_instance" {
  name         = "${var.instance_name}"
  zone         = "${var.instance_zone}"
  machine_type = "${var.instance_type}"
  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-9"
      }
  }
  network_interface {
    network = "${var.instance_network}"
    access_config {
      # Allocate a one-to-one NAT IP to the instance
    }
  }
}

Initialisation de terraforma :

terraform init

Affichage du plan :

terraform plan

Réaliser le déploiement :

terraform apply

Dataflow VS Dataproc :

Dataflow : Cloud Dataflow permet d'exécuter des tâches de traitement de données de toute taille.

Dataproc : Dataproc est un service entièrement géré et hautement évolutif qui permet d'exécuter Apache Spark, Apache Flink, Presto et plus de 30 outils et frameworks Open Source. Entièrement intégré à Google Cloud, Dataproc vous permet de moderniser vos lacs de données, d'effectuer des tâches d'ETL et de sécuriser la science des données à l'échelle mondiale et pour un moindre coût.