Créer un cluster hybride Google Distributed Cloud sur des VM Compute Engine

Cette page explique comment configurer un cluster hybride Google Distributed Cloud en mode haute disponibilité à l'aide de machines virtuelles (VM) exécutées sur Compute Engine.

Important : Ce déploiement n'est fourni qu'à des fins d'évaluation. N'exécutez pas Google Distributed Cloud sur des VM Compute Engine en production. Pour la production, suivez les étapes de notre guide de démarrage rapide afin d'installer Google Distributed Cloud sur votre matériel.

Vous pouvez essayer Google Distributed Cloud rapidement, sans avoir à préparer de matériel. Une fois les étapes décrites sur cette page effectuées, vous disposerez d'un environnement de test Google Distributed Cloud opérationnel qui s'exécute sur Compute Engine.

Pour essayer Google Distributed Cloud sur des VM Compute Engine, procédez comme suit :

1. Créer six VM dans Compute Engine
2. Créez un réseau vxlan avec une connectivité L2 entre toutes les VM.
3. Installer les prérequis pour Google Distributed Cloud

4. Déployer un cluster hybride Google Distributed Cloud

5. Vérifiez le cluster.

Avant de commencer

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

5. Make sure that billing is enabled for your Google Cloud project.

6. Notez l'ID de projet, car vous en aurez besoin pour définir une variable d'environnement utilisée dans les scripts et les commandes de cette page. Si vous avez sélectionné un projet existant, assurez-vous d'en être le propriétaire ou l'éditeur.
7. Sur votre poste de travail Linux, assurez-vous d'avoir installé la dernière version de Google Cloud CLI, l'outil de ligne de commande permettant d'interagir avec Google Cloud. Si la gcloud CLI est déjà installée, mettez à jour ses composants en exécutant la commande suivante :

   gcloud components update

   Selon la manière dont la gcloud CLI a été installée, le message suivant peut s'afficher : "Vous ne pouvez pas effectuer cette action, car le gestionnaire de composants de Google Cloud CLI est désactivé pour cette installation. Vous pouvez exécuter la commande suivante pour obtenir le même résultat pour cette installation :" Suivez les instructions pour copier et coller la commande afin de mettre à jour les composants.

Les étapes de ce guide proviennent du script d'installation du dépôt anthos-samples. La section des questions fréquentes contient davantage d'informations sur la personnalisation de ce script pour qu'il fonctionne avec certaines variantes populaires.

Créer six VM dans Compute Engine

Pour créer les VM suivantes, procédez comme suit :

• Une VM pour le poste de travail administrateur. Une station de travail administrateur héberge des outils d'interface de ligne de commande (CLI) et des fichiers de configuration permettant de provisionner les clusters lors de l'installation, ainsi que des outils d'interface de ligne de commande permettant d'interagir avec les clusters provisionnés après l'installation. Le poste de travail administrateur aura accès à tous les autres nœuds du cluster via SSH.
• Trois VM pour les trois nœuds du plan de contrôle nécessaires à l'exécution du plan de contrôle Google Distributed Cloud.
• Deux VM pour les deux nœuds de calcul nécessaires à l'exécution de charges de travail sur le cluster Google Distributed Cloud.

1. Configurez des variables d'environnement :

   export PROJECT_ID=PROJECT_ID
   export ZONE=ZONE
   export CLUSTER_NAME=CLUSTER_NAME
   export BMCTL_VERSION=1.30.100-gke.96
   

   Pour ZONE, vous pouvez utiliser us-central1-a ou l'une des autres zones Compute Engine.

2. Exécutez les commandes suivantes pour vous connecter avec votre compte Google et définir votre projet comme projet par défaut :

   gcloud auth login
   gcloud config set project $PROJECT_ID
   gcloud config set compute/zone $ZONE
   

3. Créez le compte de service et la clé baremetal-gcr :

   gcloud iam service-accounts create baremetal-gcr
   
   gcloud iam service-accounts keys create bm-gcr.json \
       --iam-account=baremetal-gcr@"${PROJECT_ID}".iam.gserviceaccount.com

   Remarque : Les clés de compte de service constituent un risque pour la sécurité si elles ne sont pas gérées correctement. Vous êtes responsable de la sécurité de la clé privée et des autres opérations décrites dans la section Bonnes pratiques de gestion des clés de compte de service. Si vous ne parvenez pas à créer une clé de compte de service, la création de clé de compte de service peut être désactivée pour votre organisation. Pour en savoir plus, consultez la page Gérer les ressources d'organisation sécurisées par défaut.

4. Activez les API et services Google Cloud :

   gcloud services enable \
       anthos.googleapis.com \
       anthosaudit.googleapis.com \
       anthosgke.googleapis.com \
       cloudresourcemanager.googleapis.com \
       connectgateway.googleapis.com \
       container.googleapis.com \
       gkeconnect.googleapis.com \
       gkehub.googleapis.com \
       serviceusage.googleapis.com \
       stackdriver.googleapis.com \
       monitoring.googleapis.com \
       logging.googleapis.com \
       opsconfigmonitoring.googleapis.com \
       compute.googleapis.com \
       gkeonprem.googleapis.com \
       iam.googleapis.com \
       kubernetesmetadata.googleapis.com

5. Accordez au compte de service baremetal-gcr des autorisations supplémentaires pour ne pas avoir besoin de plusieurs comptes de service pour différents API et services :

   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/gkehub.connect" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/gkehub.admin" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/logging.logWriter" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/monitoring.metricWriter" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/monitoring.dashboardEditor" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/stackdriver.resourceMetadata.writer" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/opsconfigmonitoring.resourceMetadata.writer" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
       --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
       --role="roles/kubernetesmetadata.publisher" \
       --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/monitoring.viewer" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/serviceusage.serviceUsageViewer" \
     --no-user-output-enabled

6. Créez les variables et les tableaux nécessaires pour toutes les commandes de cette page :

   MACHINE_TYPE=n1-standard-8
   VM_PREFIX=abm
   VM_WS=$VM_PREFIX-ws
   VM_CP1=$VM_PREFIX-cp1
   VM_CP2=$VM_PREFIX-cp2
   VM_CP3=$VM_PREFIX-cp3
   VM_W1=$VM_PREFIX-w1
   VM_W2=$VM_PREFIX-w2
   declare -a VMs=("$VM_WS" "$VM_CP1" "$VM_CP2" "$VM_CP3" "$VM_W1" "$VM_W2")
   declare -a IPs=()

7. Utilisez la boucle suivante pour créer six VM :

   Remarque : Si vous souhaitez déployer des VM à l'aide de l'environnement d'exécution des VM Anthos, pour de meilleures performances, activez la virtualisation du matériel en ajoutant --enable-nested-virtualization à la commande gcloud suivante.
   for vm in "${VMs[@]}"
   do
       gcloud compute instances create "$vm" \
         --image-family=ubuntu-2004-lts --image-project=ubuntu-os-cloud \
         --zone="${ZONE}" \
         --boot-disk-size 200G \
         --boot-disk-type pd-ssd \
         --can-ip-forward \
         --network default \
         --tags http-server,https-server \
         --min-cpu-platform "Intel Haswell" \
         --enable-nested-virtualization \
         --scopes cloud-platform \
         --machine-type "$MACHINE_TYPE" \
         --metadata "cluster_id=${CLUSTER_NAME},bmctl_version=${BMCTL_VERSION}"
       IP=$(gcloud compute instances describe "$vm" --zone "${ZONE}" \
            --format='get(networkInterfaces[0].networkIP)')
       IPs+=("$IP")
   done

   Cette commande crée des instances de VM avec les noms suivants :

   • abm-ws : VM du poste de travail administrateur.
   • abm-cp1, abm-cp2, abm-cp3 : VM des nœuds du plan de contrôle.
   • abm-w1, abm-w2 : VM des nœuds qui exécutent des charges de travail.

8. Utilisez la boucle suivante pour vérifier que SSH est prêt sur toutes les VM :

   for vm in "${VMs[@]}"
   do
       while ! gcloud compute ssh root@"$vm" --zone "${ZONE}" --command "printf 'SSH to $vm succeeded\n'"
       do
           printf "Trying to SSH into %s failed. Sleeping for 5 seconds. zzzZZzzZZ" "$vm"
           sleep  5
       done
   done

Créer un réseau vxlan avec une connectivité L2 entre les VM

Utilisez la fonctionnalité vxlan standard de Linux pour créer un réseau qui connecte toutes les VM avec la connectivité L2.

La commande suivante contient deux boucles effectuant les actions suivantes :

1. Connexion en SSH à chaque VM
2. Mise à jour et installation des packages nécessaires

3. Exécution des commandes requises pour configurer le réseau avec vxlan

   i=2 # We start from 10.200.0.2/24
   for vm in "${VMs[@]}"
   do
       gcloud compute ssh root@"$vm" --zone "${ZONE}" << EOF
           apt-get -qq update > /dev/null
           apt-get -qq install -y jq > /dev/null
           set -x
           ip link add vxlan0 type vxlan id 42 dev ens4 dstport 0
           current_ip=\$(ip --json a show dev ens4 | jq '.[0].addr_info[0].local' -r)
           printf "VM IP address is: \$current_ip"
           for ip in ${IPs[@]}; do
               if [ "\$ip" != "\$current_ip" ]; then
                   bridge fdb append to 00:00:00:00:00:00 dst \$ip dev vxlan0
               fi
           done
           ip addr add 10.200.0.$i/24 dev vxlan0
           ip link set up dev vxlan0
   
   EOF
       i=$((i+1))
   done

Vous disposez désormais d'une connectivité L2 au sein du réseau 10.200.0.0/24. Les VM ont les adresses IP suivantes :

• VM de poste de travail d'administrateur : 10.200.0.2
• VM exécutant les nœuds du plan de contrôle :
  • 10.200.0.3
  • 10.200.0.4
  • 10.200.0.5
• VM exécutant les nœuds de calcul :
  • 10.200.0.6
  • 10.200.0.7

Installer les prérequis pour Google Distributed Cloud

Vous devez installer les outils suivants sur la station de travail de l'administrateur avant d'installer Google Distributed Cloud :

• bmctl
• kubectl
• Docker

Pour installer les outils et préparer l'installation de Google Distributed Cloud :

1. Exécutez les commandes suivantes pour télécharger la clé de compte de service sur la station de travail de l'administrateur et installer les outils requis :

   gcloud compute ssh root@$VM_WS --zone "${ZONE}" << EOF
   set -x
   
   export PROJECT_ID=\$(gcloud config get-value project)
   BMCTL_VERSION=\$(curl http://metadata.google.internal/computeMetadata/v1/instance/attributes/bmctl_version -H "Metadata-Flavor: Google")
   export BMCTL_VERSION
   
   gcloud iam service-accounts keys create bm-gcr.json \
     --iam-account=baremetal-gcr@\${PROJECT_ID}.iam.gserviceaccount.com
   
   curl -LO "https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl"
   
   chmod +x kubectl
   mv kubectl /usr/local/sbin/
   mkdir baremetal && cd baremetal
   gsutil cp gs://anthos-baremetal-release/bmctl/$BMCTL_VERSION/linux-amd64/bmctl .
   chmod a+x bmctl
   mv bmctl /usr/local/sbin/
   
   cd ~
   printf "Installing docker"
   curl -fsSL https://get.docker.com -o get-docker.sh
   sh get-docker.sh
   EOF

2. Exécutez les commandes suivantes pour vous assurer que root@10.200.0.x fonctionne. Les commandes effectuent les tâches suivantes :

   1. Génération d'une nouvelle clé SSH sur la machine d'administration
   2. Ajout de la clé publique à toutes les autres VM du déploiement
   gcloud compute ssh root@$VM_WS --zone "${ZONE}" << EOF
   set -x
   ssh-keygen -t rsa -N "" -f /root/.ssh/id_rsa
   sed 's/ssh-rsa/root:ssh-rsa/' ~/.ssh/id_rsa.pub > ssh-metadata
   for vm in ${VMs[@]}
   do
       gcloud compute instances add-metadata \$vm --zone ${ZONE} --metadata-from-file ssh-keys=ssh-metadata
   done
   EOF

Déployer un cluster hybride Google Distributed Cloud

Le bloc de code suivant contient toutes les commandes et configurations nécessaires à la réalisation des tâches suivantes :

1. Création du fichier de configuration pour le cluster hybride nécessaire
2. Exécution des vérifications préliminaires
3. Déployez le cluster.

gcloud compute ssh root@$VM_WS --zone "${ZONE}" <<EOF
set -x
export PROJECT_ID=$(gcloud config get-value project)
CLUSTER_NAME=\$(curl http://metadata.google.internal/computeMetadata/v1/instance/attributes/cluster_id -H "Metadata-Flavor: Google")
BMCTL_VERSION=\$(curl http://metadata.google.internal/computeMetadata/v1/instance/attributes/bmctl_version -H "Metadata-Flavor: Google")
export CLUSTER_NAME
export BMCTL_VERSION
bmctl create config -c \$CLUSTER_NAME
cat > bmctl-workspace/\$CLUSTER_NAME/\$CLUSTER_NAME.yaml << EOB
---
gcrKeyPath: /root/bm-gcr.json
sshPrivateKeyPath: /root/.ssh/id_rsa
gkeConnectAgentServiceAccountKeyPath: /root/bm-gcr.json
gkeConnectRegisterServiceAccountKeyPath: /root/bm-gcr.json
cloudOperationsServiceAccountKeyPath: /root/bm-gcr.json
---
apiVersion: v1
kind: Namespace
metadata:
  name: cluster-\$CLUSTER_NAME
---
apiVersion: baremetal.cluster.gke.io/v1
kind: Cluster
metadata:
  name: \$CLUSTER_NAME
  namespace: cluster-\$CLUSTER_NAME
spec:
  type: hybrid
  anthosBareMetalVersion: \$BMCTL_VERSION
  gkeConnect:
    projectID: \$PROJECT_ID
  controlPlane:
    nodePoolSpec:
      clusterName: \$CLUSTER_NAME
      nodes:
      - address: 10.200.0.3
      - address: 10.200.0.4
      - address: 10.200.0.5
  clusterNetwork:
    pods:
      cidrBlocks:
      - 192.168.0.0/16
    services:
      cidrBlocks:
      - 172.26.232.0/24
  loadBalancer:
    mode: bundled
    ports:
      controlPlaneLBPort: 443
    vips:
      controlPlaneVIP: 10.200.0.49
      ingressVIP: 10.200.0.50
    addressPools:
    - name: pool1
      addresses:
      - 10.200.0.50-10.200.0.70
  clusterOperations:
    # might need to be this location
    location: us-central1
    projectID: \$PROJECT_ID
  storage:
    lvpNodeMounts:
      path: /mnt/localpv-disk
      storageClassName: node-disk
    lvpShare:
      numPVUnderSharedPath: 5
      path: /mnt/localpv-share
      storageClassName: local-shared
  nodeConfig:
    podDensity:
      maxPodsPerNode: 250
---
apiVersion: baremetal.cluster.gke.io/v1
kind: NodePool
metadata:
  name: node-pool-1
  namespace: cluster-\$CLUSTER_NAME
spec:
  clusterName: \$CLUSTER_NAME
  nodes:
  - address: 10.200.0.6
  - address: 10.200.0.7
EOB

bmctl create cluster -c \$CLUSTER_NAME
EOF

Vérifier le cluster

Vous trouverez le fichier kubeconfig de votre cluster sur la station de travail de l'administrateur, dans le répertoire bmctl-workspace du compte racine. Pour vérifier votre déploiement, procédez comme suit :

1. Connectez-vous en SSH au poste de travail administrateur en tant qu'utilisateur racine :

   gcloud compute ssh root@abm-ws --zone ${ZONE}
   

   Vous pouvez ignorer les messages concernant la mise à jour de la VM et terminer ce tutoriel. Si vous prévoyez de conserver les VM en tant qu'environnement de test, vous pouvez mettre à jour l'OS ou passer à la version suivante, comme décrit dans la documentation Ubuntu.

2. Définissez la variable d'environnement KUBECONFIG avec le chemin d'accès au fichier de configuration du cluster pour exécuter les commandes kubectl sur le cluster.

   export clusterid=CLUSTER_NAME
   export KUBECONFIG=$HOME/bmctl-workspace/$clusterid/$clusterid-kubeconfig
   kubectl get nodes
   

3. Définissez le contexte actuel dans une variable d'environnement :

   export CONTEXT="$(kubectl config current-context)"
   

4. Exécutez la commande gcloud suivante : Cette commande :

   • Attribue le rôle Kubernetes clusterrole/cluster-admin à votre compte utilisateur sur le cluster.
   • Configure le cluster afin que vous puissiez exécuter des commandes kubectl sur votre ordinateur local sans avoir à vous connecter en SSH au poste de travail administrateur.

   Remplacez GOOGLE_ACCOUNT_EMAIL par l'adresse e-mail associée à votre compte Google Cloud. Exemple : --users=[e-mail].

   gcloud container fleet memberships generate-gateway-rbac  \
       --membership=CLUSTER_NAME \
       --role=clusterrole/cluster-admin \
       --users=GOOGLE_ACCOUNT_EMAIL \
       --project=PROJECT_ID \
       --kubeconfig=$KUBECONFIG \
       --context=$CONTEXT\
       --apply
   

   Le résultat de cette commande ressemble à ce qui suit, qui est tronqué pour des raisons de lisibilité :

   Validating input arguments.
   Specified Cluster Role is: clusterrole/cluster-admin
   Generated RBAC policy is:
   --------------------------------------------
   ...
   
   Applying the generate RBAC policy to cluster with kubeconfig: /root/bmctl-workspace/CLUSTER_NAME/CLUSTER_NAME-kubeconfig, context: CLUSTER_NAME-admin@CLUSTER_NAME
   Writing RBAC policy for user: GOOGLE_ACCOUNT_EMAIL to cluster.
   Successfully applied the RBAC policy to cluster.
   

5. Lorsque vous avez terminé d'explorer, saisissez exit pour vous déconnecter du poste de travail de l'administrateur.

6. Obtenez l'entrée kubeconfig qui peut accéder au cluster via la passerelle Connect.

   gcloud container fleet memberships get-credentials CLUSTER_NAME
   

   Le résultat ressemble à ce qui suit :

   Starting to build Gateway kubeconfig...
   Current project_id: PROJECT_ID
   A new kubeconfig entry "connectgateway_PROJECT_ID_global_CLUSTER_NAME" has been generated and set as the current context.
   

7. Vous pouvez maintenant exécuter des commandes kubectl via la passerelle Connect :

   kubectl get nodes
   kubectl get namespaces
   

Se connecter à votre cluster depuis la console Google Cloud

Pour observer vos charges de travail sur Google Distributed Cloud dans la console Google Cloud, vous devez vous connecter au cluster. Avant de vous connecter à la console pour la première fois, vous devez configurer une méthode d'authentification. La méthode d'authentification la plus simple à configurer est Google Identity. Cette méthode d'authentification vous permet de vous connecter à l'aide de l'adresse e-mail associée à votre compte Google Cloud.

La commande gcloud container fleet memberships generate-gateway-rbac que vous avez exécutée dans la section précédente configure le cluster afin que vous puissiez vous connecter avec votre identité Google.

1. Dans la console Google Cloud, accédez à la page Clusters GKE.

   Accéder aux clusters GKE

2. Cliquez sur Actions à côté du cluster enregistré, puis sur Se connecter.

3. Sélectionnez Utilisez votre identité Google pour vous connecter.

4. Cliquez sur Login (Connexion).

Effectuer un nettoyage

1. Connectez-vous à la station de travail d'administration pour réinitialiser les VM de cluster à leur état avant l'installation et pour annuler l'enregistrement du cluster dans votre projet Google Cloud:

   gcloud compute ssh root@abm-ws --zone ${ZONE} << EOF
   set -x
   export clusterid=CLUSTER_NAME
   bmctl reset -c \$clusterid
   EOF
   

2. Répertoriez toutes les VM dont le nom contient abm :

   gcloud compute instances list | grep 'abm'
   

3. Vérifiez que vous êtes prêt à supprimer toutes les VM dont le nom contient abm.

   Une fois la vérification effectuée, vous pouvez supprimer les VM abm en exécutant la commande suivante :

   gcloud compute instances list --format="value(name)" | grep 'abm'  | xargs gcloud \
       --quiet compute instances delete