Comprendre les vérifications préliminaires

Avec les clusters Anthos sur Bare Metal, vous pouvez effectuer des vérifications préliminaires dans différentes situations :

Les clusters Anthos sur Bare Metal effectuent des vérifications préliminaires lorsque vous créez ou mettez à jour des clusters d'administrateur, des clusters hybrides ou autonomes, ainsi que des ressources de pool de nœuds avec bmctl. En cas d'échec des vérifications, aucune modification n'est effectuée. Vous pouvez également contourner ces vérifications.
Vous pouvez exécuter un ensemble limité de vérifications préliminaires avant de créer des clusters d'utilisateur à partir d'un cluster d'administrateur ou hybride à l'aide de la commande kubectl.
Les clusters Anthos sur Bare Metal exécutent également des vérifications internes préliminaires lorsque vous appliquez des ressources Kubernetes aux clusters d'utilisateur à partir d'un cluster d'administrateur ou hybride. Les vérifications sont exécutées avant que les modifications ne soient réellement appliquées aux clusters d'utilisateur concernés. En cas d'échec des vérifications, aucune modification n'est effectuée. Vous pouvez également contourner ces vérifications ou les exécuter explicitement.

Vérifications préliminaires lors de la création de clusters à l'aide de `bmctl`

Lorsque vous créez des clusters d'administrateur, hybrides ou autonomes avec la commande bmctl, les clusters Anthos sur Bare Metal exécutent automatiquement des vérifications préliminaires avant toute modification.

Une fois les vérifications réussies, les clusters Anthos sur Bare Metal créent les clusters.

Ignorer les résultats des vérifications préliminaires automatiques

Si vous souhaitez contourner ces vérifications préliminaires automatiques, vous pouvez utiliser l'option facultative --force dans la commande.

Exécuter des vérifications préliminaires indépendantes

Vous pouvez également effectuer vous-même des vérifications préliminaires avant de créer un cluster. Cela peut vous faire gagner du temps en vous assurant que vos ressources machine et de nœud répondent aux besoins des vérifications.

La commande suivante valide le fichier de configuration de cluster spécifié, mais n'essaie pas de créer le cluster lui-même :
```
bmctl check config --cluster CLUSTER_NAME
```
Cette commande vérifie si les machines et le réseau sont prêts à créer le cluster :
```
bmctl check preflight --cluster CLUSTER_NAME
```

Notez que vous ne pouvez pas créer de clusters d'utilisateur avec bmctl (et une vérification préliminaire permet d'éviter cela).

Vérifications préliminaires pour la création d'un cluster d'utilisateur

Les clusters d'utilisateur sont créés à partir d'un cluster d'administrateur ou hybride existant. Vous exécutez les vérifications préliminaires à l'aide de kubectl. En fonction des résultats de ces vérifications, vous pouvez déterminer s'il y a des erreurs et les corriger avant la création du cluster d'utilisateur.

Une fois qu'un cluster d'administrateur ou hybride est créé et en cours d'exécution, vous pouvez utiliser kubectl pour exécuter des vérifications préliminaires avant la création d'un cluster utilisateur.

Créez un fichier de configuration de cluster d'utilisateur en suivant la procédure décrite dans la page Créer des clusters d'utilisateur dans une configuration multicluster.
Créez un espace de noms pour le nouveau cluster d'utilisateur. Par exemple, pour créer un cluster d'utilisateur nommé user1, vous pouvez créer un espace de noms nommé cluster-user1. Voici la commande kubectl permettant de créer l'espace de noms, où ADMIN_KUBECONFIG spécifie le chemin d'accès au fichier kubeconfig du cluster d'administrateur :
```
kubectl --kubeconfig ADMIN_KUBECONFIG create namespace cluster-user1
```
Importez votre fichier de clé privée SSH dans le nouvel espace de noms en tant que secret pour définir vos identifiants. Voici un exemple de commande, où ADMIN_KUBECONFIG spécifie le chemin d'accès au fichier kubeconfig du cluster administrateur et SSH_PRIVATE_KEY_FILE_PATH spécifie le chemin d'accès au fichier de clé privée SSH :
```
kubectl --kubeconfig ADMIN_KUBECONFIG create secret generic ssh-key -n cluster-user1 --from-file=id_rsa=SSH_PRIVATE_KEY_FILE_PATH
```
Créez un fichier YAML de vérification préliminaire avec la structure suivante : Dans le champ configYAML, saisissez le contenu textuel du fichier de configuration de cluster d'utilisateur que vous avez créé à l'étape 1 :
```
apiVersion: baremetal.cluster.gke.io/v1
kind: PreflightCheck
metadata:
generateName: preflightcheck-
namespace: cluster-user1
spec:
configYAML: |
# insert user cluster config file content here.
```
La commande kubectl suivante exécute la vérification préliminaire pour le cluster d'utilisateur, où ADMIN_KUBECONFIG spécifie le chemin d'accès au fichier kubeconfig du cluster d'administrateur, et USER_CLUSTER_PREFLIGHT_CHECK_CONFIG spécifie le chemin d'accès au fichier YAML de vérification préliminaire que vous avez créé à l'étape précédente :
```
kubectl --kubeconfig ADMIN_KUBECONFIG create -f USER_CLUSTER_PREFLIGHT_CHECK_CONFIG
```
Par exemple, pour un cluster d'administrateur nommé cluster1 et une configuration de vérification préliminaire de cluster d'utilisateur nommée user1-preflight.yaml, la commande est la suivante :
```
kubectl --kubeconfig bmctl-workspace/cluster1/cluster1-kubeconfig create -f user1-preflight.yaml
```
Le système renvoie le message suivant, avec l'ID de la tâche de vérification préliminaire :
```
preflightcheck.baremetal.cluster.gke.io/preflightcheck-g7hfo4 created
```

Pour obtenir l'état de la tâche de vérification préliminaire, utilisez la commande kubectl :

kubectl --kubeconfig bmctl-workspace/cluster1/cluster1-kubeconfig -n cluster-user1 get preflightchecks preflightcheck-g7hfo4

En cas d'échec de la tâche de vérification préliminaire, vérifiez son état, puis consultez les journaux de tâches détaillés pour identifier la vérification en question. Corrigez les problèmes mentionnés dans les tâches en conséquence, puis exécutez de nouveau les vérifications.

Vérifications préliminaires internes sur les clusters existants

Les clusters Anthos sur Bare Metal effectuent également des vérifications préliminaires internes lorsque vous appliquez des ressources Kubernetes à un cluster d'administrateur ou hybride existant. Si l'une des vérifications échoue, les clusters Anthos sur Bare Metal n'apportent aucune modification aux nœuds associés, sauf si vous avez spécifiquement contourné ces vérifications.

Contourner les vérifications préliminaires lors de l'application de ressources Kubernetes

Pour ignorer les vérifications préliminaires internes lors de l'application de ressources à des clusters existants, vous devez définir le champ BypassPreflightCheck sur true dans le fichier YAML du cluster.

Voici un fragment d'un fichier de configuration YAML du cluster, avec le champ bypassPreflightCheck défini sur true.

# Sample cluster config to bypass preflight check errors:

apiVersion: v1
kind: Namespace
metadata:
  name: cluster-user1
---
apiVersion: baremetal.cluster.gke.io/v1
kind: Cluster
metadata:
  name: user1
  namespace: cluster-user1
spec:
  type: user
  bypassPreflightCheck: true
  # Anthos cluster version.
  anthosBareMetalVersion: v1.6.2
....

Réactiver les vérifications préliminaires

Vous pouvez déclencher explicitement une nouvelle série de vérifications préliminaires afin que les clusters Anthos sur Bare Metal puissent mettre à jour ou créer des clusters une fois la vérification préliminaire réussie.

Créez un fichier YAML de vérification préliminaire avec le contenu suivant : Renseignez les champs namespace et clusterName avec le nom du cluster que vous créez :

apiVersion: baremetal.cluster.gke.io/v1
kind: PreflightCheck
metadata:
generateName: preflightcheck-
namespace: CLUSTER_NAMESPACE
spec:
clusterName: CLUSTER_NAME

Exécutez la commande kubectl afin d'exécuter la vérification préliminaire pour le cluster, où ADMIN_KUBECONFIG spécifie le chemin d'accès au fichier kubeconfig du cluster d'administrateur, et CLUSTER_PREFLIGHT_CHECK_CONFIG spécifie le chemin d'accès au fichier YAML de vérification préliminaire que vous avez créé précédemment à l'étape 1 des vérifications préliminaires pour les clusters d'utilisateur :
```
kubectl --kubeconfig ADMIN_KUBECONFIG create -f CLUSTER_PREFLIGHT_CHECK_CONFIG
```
Par exemple, pour un cluster d'administrateur nommé cluster1 et une configuration de vérification préliminaire de cluster d'utilisateur nommée user1-preflight.yaml, la commande est la suivante :
```
kubectl --kubeconfig bmctl-workspace/cluster1/cluster1-kubeconfig create -f user1-preflight.yaml
```
Le système répond avec l'ID de la tâche de vérification préliminaire :
```
preflightcheck.baremetal.cluster.gke.io/preflightcheck-g7hfo4 created
```

Pour obtenir l'état de l'ID de la tâche de vérification préliminaire, utilisez la commande kubectl :

kubectl --kubeconfig bmctl-workspace/cluster1/cluster1-kubeconfig -n cluster-cluster1 get preflightchecks preflightcheck-g7hfo4

Une fois la tâche de vérification préliminaire terminée, les clusters Anthos sur Bare Metal créent le cluster et ses ressources.

Détails des vérifications préliminaires lors de l'installation

Les clusters Anthos sur Bare Metal vérifient diverses conditions préalables concernant le système d'exploitation, les logiciels et les machines lors de l'exécution des vérifications préliminaires.

Pour en savoir plus, consultez la page Présentation des conditions préalables à l'installation.