Google Cloud Shell

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

Renommer une VM :

gcloud beta compute instances set-name OLD --new-name=NEW

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