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

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 :

Quelques notes :

LINUX :

Example de clef SSH :

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

Windows :

Activer le compte Administrateur :

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

Vous devez réaliser cette procédure si vous souhaitez activer les service ADDS dans le cloud !

Définir des variables :

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

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

Notes Challenge :

gcloud config set project qwiklabs-gcp-04-9e1e3d54216e




# 1
gcloud compute instances create nucleus-jumphost-262 --machine-type=f1-micro --zone=us-east1-b

# 2
gcloud container clusters create mon-cluster --project qwiklabs-gcp-04-9e1e3d54216e --zone=us-east1-b
gcloud container clusters get-credentials mon-cluster --project qwiklabs-gcp-04-9e1e3d54216e --zone=us-east1-b

kubectl create deployment hello-server --image=gcr.io/google-samples/hello-app:2.0
kubectl expose deployment hello-server --type=LoadBalancer --port 8083
gcloud container clusters get-credentials mon-cluster --zone=us-east1-b

# 3
gcloud config set compute/zone us-east1-b



# Créer un modèle d'instance  OK
gcloud compute instance-templates create ngnix-group-template \
   --region=europe-west1 \
   --network=default \
   --machine-type=f1-micro \
   --tags network-lb-tag \
   --metadata=startup-script="#! /bin/bash
    apt-get update
    apt-get install -y nginx
    service nginx start
    sed -i -- 's/nginx/Google Cloud Platform - '"\$HOSTNAME"'/' /var/www/html/index.nginx-debian.html"



# Créer un pool cible

gcloud compute target-pools create nginx-pool \
    --region europe-west1 

# Créer un groupe d'instances géré

gcloud compute instance-groups managed create lb-backend-group \
   --template=ngnix-group-template --size=2 --zone=europe-west1-b --base-instance-name nginx 

# Créer la règle de pare feu :

gcloud compute firewall-rules create grant-tcp-rule-473 \
    --allow=tcp:80

gcloud compute forwarding-rules create nginx-lb \
--region europe-west1  \
--ports=80 \
--target-pool nginx-pool

5 .Create a health check :

gcloud compute http-health-checks create http-basic-check

gcloud compute instance-groups managed \
set-named-ports nginx-group \
--named-ports http:80


# Créer un service de backend et l'associer au groupe d'instances géré


gcloud compute backend-services create web-backend-service \
    --protocol HTTP --http-health-checks http-basic-check --global


gcloud compute backend-services add-backend web-backend-service \
    --instance-group ngnix-group \
    --instance-group-zone=europe-west1-b \
    --global



# Créer un mappage d'URL et un proxy HTTP cible pour acheminer les demandes vers votre mappage d'URL

gcloud compute url-maps create web-map \
    --default-service nginx-backend

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

# Créer une règle de transfert

gcloud compute forwarding-rules create http-content-rule \
    --global \
    --target-http-proxy http-lb-proxy \
    --ports 80


####### Correction 


gcloud config set compute/zone europe-west1-b



cat << EOF > startup.sh
#! /bin/bash
apt-get update
apt-get install -y nginx
service nginx start
sed -i -- 's/nginx/Google Cloud Platform - '"\$HOSTNAME"'/' /var/www/html/index.nginx-debian.html
EOF

1 .Create an instance template :

gcloud compute instance-templates create nginx-template \
--metadata-from-file startup-script=startup.sh

2 .Create a target pool :

gcloud compute target-pools create nginx-pool

3 .Create a managed instance group :

gcloud compute instance-groups managed create nginx-group \
--base-instance-name nginx \
--size 2 \
--template nginx-template \
--target-pool nginx-pool

gcloud compute instances list

4 .Create a firewall rule to allow traffic (80/tcp) :

gcloud compute firewall-rules create allow-tcp-rule-375 --allow tcp:80

gcloud compute forwarding-rules create nginx-lb \
--region europe-west1 \
--ports=80 \
--target-pool nginx-pool

gcloud compute forwarding-rules list

5 .Create a health check :

gcloud compute http-health-checks create http-basic-check

gcloud compute instance-groups managed \
set-named-ports nginx-group \
--named-ports http:80

6 .Create a backend service and attach the manged instance group :

gcloud compute backend-services create nginx-backend \
--protocol HTTP --http-health-checks http-basic-check --global

gcloud compute backend-services add-backend nginx-backend \
--instance-group nginx-group \
--instance-group-zone europe-west1-b \
--global

7 .Create a URL map and target HTTP proxy to route requests to your URL map :

gcloud compute url-maps create web-map \
--default-service nginx-backend

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

8 .Create a forwarding rule :

gcloud compute forwarding-rules create http-content-rule \
--global \
--target-http-proxy http-lb-proxy \
--ports 80

gcloud compute forwarding-rules list

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

Create a Deployment Manager deployment :

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

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

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

Créer un IAM Service Account :

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 :

Choisir un type de load balancing :

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 :