Use data disk snapshots to pre-warm images for faster ACK node scale-out - Container Service for Kubernetes

Dans les scénarios tels que l'IA et le big data qui nécessitent des mises à l'échelle fréquentes, les nouveaux nœuds passent beaucoup de temps à extraire les images des composants et des applications lorsqu'ils rejoignent un cluster. Pour accélérer la préparation des nœuds, mettez en cache les composants et les images sur un snapshot de disque de données. Les nouveaux nœuds chargent ainsi les données directement depuis les disques locaux plutôt que via le réseau, ce qui améliore considérablement l'efficacité de la mise à l'échelle.

Fonctionnement

Lors d'une mise à l'échelle par défaut, les étapes suivantes dépendantes du réseau consomment la majeure partie du temps écoulé entre la création du nœud et l'exécution réussie de l'application sur ce nœud :

Extraction des images système : le runtime de conteneur (containerd) doit extraire les images requises pour les Pods système, tels que Terway et kube-proxy.
Extraction des images applicatives : une fois qu'un nœud est prêt, les Pods sont planifiés dessus et le runtime de conteneur doit extraire les images de conteneur de l'application.

Lorsqu'un pool de nœuds utilise un snapshot de disque de données pour la mise à l'échelle, les opérations de chargement local remplacent les opérations d'extraction réseau :

Préparation plus rapide des nœuds : le script d'initialisation vérifie d'abord les chemins locaux. Étant donné que le snapshot contient déjà les images système, le nœud ignore les processus de téléchargement et d'extraction, atteignant ainsi plus rapidement l'état Ready.
Démarrage plus rapide des applications : comme les images applicatives sont pré-mises en cache dans le snapshot, lorsque un Pod est planifié sur un nouveau nœud, le runtime de conteneur trouve les images requises localement, permettant un démarrage rapide de l'application.

Étape 1 : Préparer un nœud pour les snapshots

Créez une instance ECS contenant les composants principaux requis d'ACK et les images applicatives. Vous créerez ensuite un snapshot à partir du disque de données de cette instance.

Préparez l'instance ECS pour la création du snapshot.
1. Créez un pool de nœuds dans le cluster avec les configurations clés suivantes. Au cours de ce processus, ACK enregistre automatiquement les images des modules complémentaires, telles que Terway et l'image du composant kube-proxy, sur le disque de données.
  - Logon Type : configurez une paire de clés ou un mot de passe pour vous connecter à l'instance.
  - Expected Number of Nodes : définissez la valeur sur 1.
  - Data Disk : ajoutez au moins un disque de données.
    
    Si vous avez été approuvé pour la fonctionnalité Initialization Settings via la liste d'autorisation, sélectionnez Format and use as a directory of the container runtime. Cela garantit que l'environnement du runtime de conteneur est provisionné sur le disque de données.
2. Une fois que le nœud est prêt, retirez-le du cluster. Lors de la suppression du nœud, ne sélectionnez pas Release ECS Instance afin de conserver l'instance ECS sous-jacente.
Connectez-vous à l'instance ECS conservée et ajoutez manuellement les composants requis et les fichiers d'images au disque de données.
1. Connectez-vous à l'instance ECS et exécutez la commande lsblk -f pour afficher le chemin de montage du disque de données, tel que /var/lib/container.
2. Mettez en cache le composant kubelet.
  1. Accédez au répertoire de montage du disque de données et créez un répertoire de cache pour les composants ACK.
```
cd /var/lib/container
mkdir -p ack
```
  2. Définissez les variables d'environnement pour votre région et votre version de cluster.
```
# This example uses the cn-shanghai region and version 1.34.1-aliyun.1. Replace them with your actual values.
export REGION="cn-shanghai"
export KUBE_VERSION="1.34.1-aliyun.1"
```
  3. Téléchargez, extrayez et déplacez le fichier binaire kubelet vers le répertoire de cache.
```
wget http://aliacs-k8s-$REGION.oss-$REGION-internal.aliyuncs.com/public/pkg/kubernetes/kubernetes-$KUBE_VERSION-linux-amd64.tar.gz
tar -xvf kubernetes-$KUBE_VERSION-linux-amd64.tar.gz
mv pkg/kubernetes /var/lib/container/ack/
```
  4. Nettoyez les fichiers temporaires pour garder le snapshot léger.
```
rm kubernetes-$KUBE_VERSION-linux-amd64.tar.gz
rm -rf pkg
```
(Facultatif) Mettez en cache les images applicatives.

Extrayez les images applicatives fréquemment utilisées vers l'instance locale. Ces images seront incluses dans le snapshot, accélérant ainsi le démarrage de vos Pods applicatifs.
```
# You can also use 'docker pull' if Docker is available in your environment.
# The following command uses an Nginx image as an example.
crictl pull anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/openanolis/nginx:1.14.1-8.6
```

Étape 2 : Créer un snapshot de disque de données

Créez un snapshot à partir du disque de données contenant les composants et les images mis en cache. Ce snapshot pourra être réutilisé pour les futures mises à l'échelle du pool de nœuds.

Accédez à Console ECS - Instances, et placez l'instance cible dans l'état Stop.

Pour plus d'informations sur l'arrêt d'une instance, consultez Arrêter une instance .
Une fois l'instance arrêtée, accédez à sa page de détails et cliquez sur l'onglet EBS.
Recherchez le disque de données qui sert de répertoire au runtime de conteneur. Dans la colonne Actions, cliquez sur Create Snapshot et suivez les instructions à l'écran pour configurer le snapshot.

Pour plus d'informations sur la configuration d'un snapshot, consultez Créer manuellement un snapshot .

Étape 3 : Effectuer la mise à l'échelle avec le snapshot et vérifier les résultats

Créez un pool de nœuds et appliquez le snapshot que vous avez créé précédemment. Les configurations clés sont les suivantes :
- Operating System : sélectionnez un système d'exploitation selon vos besoins.
  
  Cette fonctionnalité n'est actuellement pas prise en charge pour ContainerOS versions 3.5 et ultérieures.
- Expected Number of Nodes : définissez la valeur sur 1 ou plus.
- Data Disk :
  - Sélectionnez From Data Disk Snapshot et choisissez le snapshot que vous avez créé.
  - Si vous avez été approuvé pour la fonctionnalité Initialization Settings via la liste d'autorisation, sélectionnez Format and use as a directory of the container runtime. Ce processus de formatage conserve les données présentes dans le snapshot.
- User Data : pour les systèmes d'exploitation autres que ContainerOS, ajoutez le script suivant pour ignorer les mises à jour yum et accélérer l'initialisation des nœuds.
```
touch /var/.skip-yum
```
Une fois que les nouveaux nœuds sont prêts, connectez-vous à un nœud et vérifiez si le cache a pris effet correctement.
1. Vérifiez l'efficacité du cache d'images.
  
  Consultez les journaux kubelet. Le cache est efficace si les journaux ne montrent aucun enregistrement d'extraction pour les images pré-mises en cache.
```
# If this command returns no output, or if the output does not contain pull records for pre-cached images like Terway or kube-proxy, the cache is effective.
journalctl -u kubelet | grep "pulled image"
```
2. Vérifiez l'efficacité du cache kubelet.
  
  Consultez le journal ack-deploy. L'absence du message check cached kubernetes failed indique que le cache est efficace.
```
# If this command returns no output, the cached kubelet was used successfully.
cat /var/log/ack-deploy.log |grep "check cached kubernetes failed"
```

Facturation

L'instance ECS temporaire utilisée pour la création du snapshot, ses disques cloud associés et le snapshot résultant engendrent tous des frais.

Une fois le processus terminé, libérez rapidement l'instance ECS temporaire. Gérez régulièrement le cycle de vie du snapshot et supprimez les snapshots inutiles pour réduire les coûts.

FAQ

Puis-je utiliser d'anciens snapshots après une mise à niveau ?

Cela n'est pas recommandé. La version de kubelet mise en cache dans le snapshot peut être incompatible avec la nouvelle version du cluster, empêchant les nœuds de s'enregistrer correctement. Après une mise à niveau du cluster, nous vous recommandons de créer un nouveau snapshot de disque de données.

Puis-je mettre en cache des fichiers autres que kubelet et des images de conteneurs ?

Oui. Tout fichier placé dans le chemin du disque de données sera inclus dans le snapshot. Vous pouvez mettre en cache d'autres fichiers dépendants, tels que des fichiers de configuration ou des modèles de données, en fonction des besoins de votre application. Veillez toutefois à gérer la taille et la conformité du contenu de vos snapshots.

Documents connexes

Processus d'initialisation des nœuds