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 | Pénalités (par Go et par Jours) |
|
Standard |
0 | 0 |
|
Nearline |
30 jours | 0.00033333 USD |
|
ColdLine |
90 jours | 0.00013333 USD |
|
Archive |
180 jours | 0.00004 USD |
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 !
| Type de stockage | Durée minimale | Pénalités | 10 Go | 100 Go | 1024 Go | 10 To |
| Standard | 0 Jour | 0 $ | 0 $ | 0 $ | 0 $ | 0 $ |
| Nearline | 30 Jours | 0,000333330 $ | 0,10 $ | 1,0 $ | 10,24 $ | 102,40 $ |
| ColdLine | 90 Jours | 0,000133330 $ | 0,12 $ | 1,2 $ | 12,29 $ | 122,88 $ |
| Archive | 180 Jours | 0,000040000 $ | 0,07 $ | 0,72 $ | 7,37 $ | 73,73 $ |
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 |
Cloud BigTable :
Prix du stockage des données :
| BIGTABLE - STOCKAGE | |||||
| Durée du stockage | 1 Go | 10 Go | 100 Go | 1024 Go | 10 To |
| Moins de 3 mois | 0,02 | 0,2 | 2 | 20,48 | 204,8 |
| Plus de trois mois | 0,01 | 0,1 | 1 | 10,24 | 102,4 |
Prix des requêtes des données :
| BIGTABLE - Données Requêtées | |||||
| 1 Go | 10 Go | 100 Go | 1024 Go | 10 To | |
| 0,0048828125 | 0,048828125 | 0,48828125 | 5 | 50 | |
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-aQuelques 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== nehemieWindows :
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-central1Cré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_IDCré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-aCréation d'un cluster avec deux noeuds :
gcloud container clusters create webfrontend --zone $MY_ZONE --num-nodes 2Déploiement d'une image :
kubectl create deploy nginx --image=nginx:1.17.10Exposition du service :
kubectl expose deployment nginx --port 80 --type LoadBalancerDéfinition des nombre de PODs qui s'exécutent sur le service :
kubectl scale deployment nginx --replicas 3Deployment 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/defaultLancer le déploiement :
gcloud deployment-manager deployments create my-first-depl --config mydeploy.yamlMettre à 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 :
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.jinjaresources:
- 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-9nano 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/mynetworkPréparation au déploiement :
gcloud deployment-manager deployments create dminfra --config=config.yaml --previewDéploiement :
gcloud deployment-manager deployments update dminfraProcéder à un déploiement automatique avec Terraform :
Création du dossier pour la configuration :
mkdir tfinfra ; cd tfinfra Définition du provider :
nano provider.tfprovider "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.tfvariable "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 initAffichage du plan :
terraform planRé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.
Choisir une solution de stockage de données :
Le challenge du transfert de données dans google Cloud:
Schéma des liens entre les datacenters de google Cloud:
Choisir une solution de déploiement cloud :
Normes des datacenters de google cloud :
Fonctionnement d'un cluster Kubernetes :
Fonctionnement du load balancing :
