Essayer Anthos clusters on bare metal sur des VM Compute Engine

Version 1.12 

• Le plus récent
• Version 1.16
• Versions antérieures (non compatibles)

Cette page vous explique comment essayer Anthos clusters on bare metal 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 Anthos clusters on bare metal sur des VM Compute Engine en production. Pour déployer Anthos clusters on bare metal en production, suivez les étapes décrites dans notre guide de démarrage rapide.

Vous pouvez essayer Anthos clusters on bare metal rapidement, sans avoir à effectuer de préparation matérielle. Après avoir effectué les étapes décrites sur cette page, vous disposerez d'un environnement de test opérationnel qui s'exécute sur Compute Engine pour votre environnement Anthos clusters on bare metal.

Pour essayer Anthos clusters on bare metal sur des VM Compute Engine, procédez comme suit :

1. Créez 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 les clusters Anthos sur bare metal
4. Déployer des clusters Anthos sur bare metal
5. Vérifiez le cluster.

Avant de commencer

Le déploiement nécessite les ressources suivantes :

• Six VM pour déployer Anthos clusters on bare metal
• Un poste de travail connecté à gcloud avec les autorisations de propriétaire pour votre projet.

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.

Remarque :Toutes les commandes sont exécutées sur une machine connectée à gcloud avec les identifiants du propriétaire ou de l'éditeur du projet.

Créer six VM dans Compute Engine

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

• Une VM d'administration utilisée pour déployer Anthos clusters on bare metal sur les autres machines
• Trois VM pour les trois nœuds du plan de contrôle nécessaires à l'exécution du plan de contrôle Anthos clusters on bare metal
• Deux VM pour les deux nœuds de calcul nécessaires à l'exécution de charges de travail sur le cluster Anthos clusters on bare metal

1. Configurez des variables d'environnement :

   export PROJECT_ID=PROJECT_ID
   export ZONE=ZONE
   export CLUSTER_NAME=CLUSTER_NAME
   export BMCTL_VERSION=1.12.9
   

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 baremetal-gcr :

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Afficher sur GitHub

   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

4. Activez les API et services Google Cloud :

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Afficher sur GitHub

   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

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 :

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Afficher sur GitHub

   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

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

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Afficher sur GitHub

   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 précédente.
   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Afficher sur GitHub

   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

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

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Afficher sur GitHub

   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écuter les commandes requises pour configurer le réseau avec vxlan

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Afficher sur GitHub

   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 d'administration : 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 éléments requis pour Anthos clusters on bare metal

Les outils suivants sont nécessaires sur la machine d'administration avant d'installer Anthos clusters on bare metal :

• bmctl
• kubectl
• Docker

1. Exécutez la commande suivante pour installer les outils nécessaires :

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Afficher sur GitHub

   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
   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Afficher sur GitHub

   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 Anthos clusters on bare metal

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.

anthos-bm-gcp-bash/install_hybrid_cluster.sh

Afficher sur GitHub

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 machine d'administration, dans le répertoire bmctl-workspace. Pour vérifier votre déploiement, procédez comme suit.

1. Connectez-vous en SSH au poste de travail administrateur :

   gcloud compute ssh root@$VM_WS --zone ${ZONE}
   

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
   

Se connecter à votre cluster depuis la console Google Cloud

Pour observer vos charges de travail sur des clusters Anthos sur solution Bare Metal dans la console Google Cloud, vous devez vous connecter à la machine d'administration sur laquelle le fichier kubeconfig du cluster est stocké.

Consultez la page Se connecter à un cluster depuis la console Google Cloud pour en savoir plus.

Effectuer un nettoyage

1. Connectez-vous à la machine 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@$VM_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