Déployer un proxy de mise en cache NFS d'espace de noyau dans Compute Engine

Ce tutoriel explique comment déployer, configurer et tester un proxy de mise en cache NFS (Network File System) basé sur Linux et un noyau Linux dans Compute Engine. L'architecture décrite dans ce tutoriel est conçue pour un scénario dans lequel les données en lecture seule sont synchronisées au niveau de l'octet à partir d'un serveur de fichiers d'origine NFS (par exemple, un serveur de fichiers NFS sur site) vers Google Cloud, ou synchronisées à la demande depuis une source principale vers plusieurs instances dupliquées en lecture seule.

Dans ce tutoriel, nous partons du principe que vous connaissez les éléments suivants :

  • Créer des versions personnalisées du système d'exploitation Linux
  • Installer et configurer des logiciels avec des scripts de démarrage dans Compute Engine
  • Configurer et gérer un système de fichiers NFS

Cette architecture n'est pas compatible avec le verrouillage de fichiers. L'architecture est particulièrement adaptée aux pipelines qui utilisent des noms de fichiers uniques pour suivre les versions de fichiers.

Architecture

L'architecture utilisée dans ce tutoriel est associée à un daemon NFS espace-noyau (KNFSD) qui agit en tant que proxy et cache NFS. Cette configuration permet à vos nœuds de calcul basés sur le cloud d'accéder à un stockage local rapide en migrant les données lorsqu'un client NFS le demande. Les nœuds client NFS écrivent des données directement sur votre serveur de fichiers d'origine NFS à l'aide de la mise en cache en écriture. Le schéma suivant illustre cette architecture :

Architecture utilisant un proxy KNFSD dans Google Cloud

Dans ce tutoriel, vous allez déployer et tester le système de proxy KNFSD. Vous créez et configurez un seul serveur NFS, un seul proxy KNFSD et un seul client NFS dans Google Cloud.

Le système de proxy KNFSD fonctionne en installant un volume à partir du serveur NFS et en le réexportant. Le client NFS installe le volume réexporté à partir du proxy. Lorsqu'un client NFS demande des données, le proxy KNFSD vérifie ses différentes tables de cache pour déterminer si les données résident localement. Si les données se trouvent déjà dans le cache, le proxy KNFSD les diffuse immédiatement. Si les données demandées ne figurent pas dans le cache, le proxy migre les données, met à jour ses tables de cache, puis diffuse les données. Le proxy KNFSD met en cache les données et les métadonnées du fichier au niveau octet. Par conséquent, seuls les octets utilisés sont transférés à mesure qu'ils sont demandés.

Le proxy KNFSD comporte deux couches de cache : L1 et L2. L1 est le cache de blocs standard du système d'exploitation qui réside dans la RAM. Lorsque le volume de données dépasse la mémoire RAM disponible, le cache L2 est mis en œuvre à l'aide de FS-Cache, un module de noyau Linux qui met en cache localement des données sur le disque. Dans ce déploiement, vous utilisez un disque SSD local comme cache L2, bien que vous puissiez configurer le système de plusieurs manières.

Pour mettre en œuvre l'architecture dans ce tutoriel, vous utilisez des outils NFS standards, compatibles avec les versions NFS 2, 3 et 4.

Déploiement de KNFSD dans une architecture hybride

Dans une architecture hybride, les clients NFS qui s'exécutent dans Google Cloud demandent des données lorsqu'ils sont nécessaires. Ces requêtes sont adressées au proxy KNFSD, qui diffuse les données de son cache local, le cas échéant. Si les données ne figurent pas dans le cache, le proxy gère la communication avec les serveurs sur site. Le système peut installer un ou plusieurs serveurs d'origine NFS. Le proxy gère toutes les communications et migrations de données nécessaires via un VPN ou une interconnexion dédiée vers les serveurs d'origine NFS sur site. Le schéma suivant illustre ce déploiement KNFSD dans une architecture hybride :

Architecture hybride avec un déploiement KNFSD.

La connectivité hybride dépasse le cadre de ce tutoriel. Pour en savoir plus sur les sujets avancés tels que le déploiement dans une architecture hybride, le scaling pour des performances élevées, ainsi que l'utilisation de métriques et de tableaux de bord pour le dépannage et le réglage, consultez les pages suivantes : Rubriques avancées sur les workflows.

Objectifs

  • Déployer et tester un système de proxy KNFSD
  • Créez et configurez les composants suivants dans Google Cloud :
    • Une image de disque personnalisée
    • Un proxy KNFSD
    • Un serveur NFS
    • Un client NFS
  • Installez un proxy NFS sur un client NFS.
  • Copiez un fichier du serveur NFS via le proxy NFS vers le client NFS.

Coûts

Ce tutoriel utilise les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Pour votre utilisation, pensez aux coûts de sortie de réseau pour les données écrites de Google Cloud dans le stockage sur site, et les coûts engendrés par la connectivité hybride.

Avant de commencer

Pour ce guide de référence, vous avez besoin d'un projet Google Cloud. Vous pouvez en créer un ou sélectionner un projet existant :

  1. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  2. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier si la facturation est activée sur un projet.

  3. Activez l'API Compute Engine

    Activer l'API

  4. Dans la console, activez Cloud Shell.

    Activer Cloud Shell

  5. Authentifiez votre connexion dans le terminal Cloud Shell :

    gcloud auth application-default login
    

    La ligne de commande vous guide tout au long du processus d'autorisation.

  6. Définissez les variables d'environnement :

    export GOOGLE_CLOUD_PROJECT=PROJECT_NAME
    gcloud config set project $GOOGLE_CLOUD_PROJECT
    

    Remplacez PROJECT_NAME par le nom du projet que vous avez créé ou sélectionné précédemment.

Une fois que vous avez terminé ce tutoriel, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Télécharger les fichiers de configuration du tutoriel

  1. Dans Cloud Shell, clonez le dépôt GitHub.

    cd ~/
    git clone https://github.com/GoogleCloudPlatform/knfsd-cache-utils.git
    
  2. Définissez le tag Git sur une version connue de qualité (dans ce cas, v0.6.4) :

    cd ~/knfsd-cache-utils
    git checkout tags/v0.6.4
    
  3. Accédez au répertoire image de votre dépôt de code :

     cd ~/knfsd-cache-utils/image
    

Configurer votre réseau

Pour des raisons de simplicité, ce tutoriel utilise le réseau VPC par défaut. Pour vous permettre de vous connecter en SSH à diverses ressources à des fins de configuration et de surveillance, ce tutoriel déploie également des adresses IP externes.

Les bonnes pratiques et architectures de référence pour la conception de VPC dépassent le cadre de ce tutoriel. Toutefois, lorsque vous intégrez ces ressources dans un environnement hybride, nous vous recommandons de respecter les bonnes pratiques suivantes :

Pour configurer votre réseau, procédez comme suit :

  • Dans Cloud Shell, définissez les variables suivantes :

    export BUILD_MACHINE_NETWORK=default
    export BUILD_MACHINE_SUBNET=default
    

Créer la machine de compilation de proxy NFS

Dans cette section, vous allez créer et vous connecter à une VM faisant office de machine de compilation de proxy NFS. Exécutez ensuite un script d'installation fourni pour mettre à jour les versions du noyau et installer tous les logiciels nécessaires au système de proxy KNFSD. L'exécution du script d'installation logicielle peut prendre quelques minutes, mais vous n'avez besoin de l'exécuter qu'une seule fois.

  1. Dans Cloud Shell, définissez les variables suivantes :

    export BUILD_MACHINE_NAME=knfsd-build-machine
    export BUILD_MACHINE_ZONE=us-central1-a
    export IMAGE_FAMILY=knfsd-proxy
    export IMAGE_NAME=knfsd-proxy-image
    
  2. Lancez l'instance de VM :

    gcloud compute instances create $BUILD_MACHINE_NAME \
      --zone=$BUILD_MACHINE_ZONE \
      --machine-type=n1-standard-16 \
      --project=$GOOGLE_CLOUD_PROJECT \
      --image-family=ubuntu-2004-lts \
      --image-project=ubuntu-os-cloud \
      --network=$BUILD_MACHINE_NETWORK \
      --subnet=$BUILD_MACHINE_SUBNET \
      --boot-disk-size=20GB \
      --boot-disk-type=pd-ssd \
      --metadata=serial-port-enable=TRUE
    

    Vous pouvez recevoir un message d'avertissement indiquant un écart de taille des disques. Vous pouvez ignorer ce message.

  3. Créez un fichier tar du logiciel requis à installer, puis copiez-le sur votre ordinateur de compilation :

    tar -czf resources.tgz -C resources .
    gcloud compute scp resources.tgz build@$BUILD_MACHINE_NAME: \
      --zone=$BUILD_MACHINE_ZONE \
      --project=$GOOGLE_CLOUD_PROJECT
    
  4. Une fois la VM démarrée, ouvrez un tunnel SSH pour celle-ci :

    gcloud compute ssh build@$BUILD_MACHINE_NAME \
      --zone=$BUILD_MACHINE_ZONE \
      --project=$GOOGLE_CLOUD_PROJECT
    
  5. Une fois le tunnel SSH établi et votre ligne de commande ciblant l'instance knfsd-build-machine, exécutez le script d'installation :

    tar -zxf resources.tgz
    sudo bash scripts/1_build_image.sh
    

    Le script clone le dépôt Ubuntu Kernel Code, met à jour la version du noyau et installe des logiciels supplémentaires. Étant donné qu'il existe un clone de dépôt, l'exécution du script peut prendre beaucoup de temps.

  6. Une fois le script d'installation terminé et que l'invite SUCCESS s'affiche, redémarrez la machine de compilation :

    sudo reboot
    

    Lorsque la machine de votre redémarrage redémarre, les messages suivants s'affichent :

    WARNING: Failed to send all data from [stdin]
    ERROR: (gcloud.compute.ssh) [/usr/bin/ssh] exited with return code [255]
    

    Ces erreurs se produisent pendant que Cloud Shell rétablit votre machine de création de proxy NFS sur votre machine hôte. Vous pouvez ignorer ces erreurs.

  7. Une fois la VM redémarrée, ouvrez à nouveau un tunnel SSH :

    gcloud compute ssh $BUILD_MACHINE_NAME \
      --zone=$BUILD_MACHINE_ZONE \
      --project=$GOOGLE_CLOUD_PROJECT
    
  8. Une fois le tunnel SSH établi et votre ligne de commande cible l'instance nfs-proxy-build, passez à Root et vérifiez la version de votre système d'exploitation :

    uname -r
    

    Le résultat est semblable à celui-ci, indiquant que les mises à jour logicielles ont réussi :

    linux <$BUILD_MACHINE_NAME> 5.13.*-gcp ...
    

    Si le résultat n'est pas semblable à l'exemple précédent, terminez ce processus pour créer à nouveau la machine proxy de compilation NFS.

  9. Nettoyez le disque local et arrêtez la machine de compilation :

    sudo bash /home/build/scripts/9_finalize.sh
    

    Les avertissements suivants s'affichent :

    userdel: user build is currently used by process 1431
    userdel: build mail spool (/var/mail/build) not found
    

    Ces avertissements se produisent pendant que Cloud Shell rebascule de votre machine de création de proxy NFS vers votre machine hôte. Vous pouvez ignorer ces erreurs.

Créer l'image de disque personnalisée

Dans cette section, vous allez créer une image personnalisée à partir de l'instance. L'image personnalisée est stockée dans un bucket Cloud Storage multirégional situé aux États-Unis.

  1. Dans Cloud Shell, définissez les variables suivantes :

    export IMAGE_NAME=knfsd-image
    export IMAGE_DESCRIPTION="first knfsd image from tutorial"
    export IMAGE_LOCATION=us
    
  2. Créez l'image disque :

    gcloud compute images create $IMAGE_NAME \
      --project=$GOOGLE_CLOUD_PROJECT \
      --description="$IMAGE_DESCRIPTION" \
      --source-disk=$BUILD_MACHINE_NAME \
      --source-disk-zone=$BUILD_MACHINE_ZONE \
      --storage-location=$IMAGE_LOCATION
    
  3. Une fois l'image disque créée, supprimez l'instance :

    gcloud compute instances delete $BUILD_MACHINE_NAME \
      --zone=$BUILD_MACHINE_ZONE
    
  4. Lorsque vous êtes invité à continuer, saisissez Y.

    Lorsque vous supprimez l'instance $BUILD_MACHINE_NAME, une invite indique que les disques associés sur la VM seront supprimés. Comme vous venez d'enregistrer une image personnalisée, vous n'avez plus besoin de ce disque temporaire, et vous pouvez le supprimer en toute sécurité.

Créer le serveur d'origine NFS

Comme mentionné précédemment, cette architecture est conçue pour connecter des ressources basées dans le cloud à un serveur de fichiers sur site. Pour simplifier le processus dans ce tutoriel, vous allez créer une ressource de secours qui s'exécute dans votre projet Cloud pour simuler cette connexion. Nommez la ressource autonome nfs-server. L'installation et la configuration du logiciel sont contenues dans un script de démarrage. Pour plus d'informations, examinez le script ~/knfsd-cache-utils/tutorial/nfs-server/1_build_nfs-server.sh.

  1. Dans Cloud Shell, accédez au répertoire des scripts nfs-server téléchargé :

    cd ~/knfsd-cache-utils/tutorial
    
  2. Créez votre serveur NFS autonome :

    gcloud compute \
      --project=$GOOGLE_CLOUD_PROJECT instances create nfs-server \
      --zone=$BUILD_MACHINE_ZONE \
      --machine-type=n1-highcpu-2 \
      --maintenance-policy=MIGRATE \
      --image-family=ubuntu-2004-lts \
      --image-project=ubuntu-os-cloud \
      --boot-disk-size=100GB \
      --boot-disk-type=pd-standard \
      --boot-disk-device-name=nfs-server \
      --metadata-from-file startup-script=nfs-server-startup.sh
    

    Ce script peut prendre quelques minutes. Un message d'avertissement peut indiquer que la taille de votre disque est inférieure à 200 Go. Vous pouvez ignorer cet avertissement.

Créer le proxy NFS

Dans cette section, vous allez créer le proxy NFS. Lorsque le proxy démarre, il configure le stockage local, prépare les options d'installation pour le serveur NFS et exporte les résultats mis en cache. Un script de démarrage fourni orchestre une grande partie de ce workflow.

  1. Dans Cloud Shell, définissez la variable suivante :

    export PROXY_NAME=nfs-proxy
    
  2. Créez la VM nfs-proxy :

    gcloud compute instances create $PROXY_NAME \
      --machine-type=n1-highmem-16 \
      --project=$GOOGLE_CLOUD_PROJECT \
      --maintenance-policy=MIGRATE \
      --zone=$BUILD_MACHINE_ZONE \
      --min-cpu-platform="Intel Skylake" \
      --image=$IMAGE_NAME \
      --image-project=$GOOGLE_CLOUD_PROJECT \
      --boot-disk-size=20GB \
      --boot-disk-type=pd-standard \
      --boot-disk-device-name=$PROXY_NAME \
      --local-ssd=interface=NVME \
      --local-ssd=interface=NVME \
      --local-ssd=interface=NVME \
      --local-ssd=interface=NVME \
      --metadata-from-file startup-script=proxy-startup.sh
    

    Un message d'avertissement indiquant que la taille de votre disque est inférieure à 200 Go peut s'afficher. Vous pouvez ignorer cet avertissement.

    Ce script configure les commandes d'installation NFS et vous permet de régler le système. Les paramètres de la version NFS, synchronisation ou asynchrone, nocto et actimeo sont certaines des variables que vous pouvez optimiser via le script de démarrage. Pour en savoir plus sur ces paramètres, consultez la section Optimiser votre système de fichiers NFS.

    La commande de cette étape définit l'option --metadata-from-file, qui injecte le script de démarrage dans votre modèle d'image. Dans ce tutoriel, vous allez utiliser un simple script proxy-startup.sh. Le script inclut des variables prédéfinies et n'inclut pas beaucoup d'options que vous souhaiterez peut-être utiliser si vous intégrez votre pipeline. Pour des cas d'utilisation plus avancés, consultez le dépôt GitHub knfsd-cache-utils.

Créer le client NFS

Au cours de cette étape, vous allez créer un seul client NFS (nommé nfs-client) pour remplacer ce qui serait probablement un groupe d'instances géré (MIG) à grande échelle.

  • Dans Cloud Shell, créez votre client NFS :

    gcloud compute \
      --project=$GOOGLE_CLOUD_PROJECT instances create nfs-client \
      --zone=$BUILD_MACHINE_ZONE \
      --machine-type=n1-highcpu-8 \
      --network-tier=PREMIUM \
      --maintenance-policy=MIGRATE \
      --image-family=ubuntu-2004-lts \
      --image-project=ubuntu-os-cloud \
      --boot-disk-size=10GB \
      --boot-disk-type=pd-standard \
      --boot-disk-device-name=nfs-client
    

    Un message d'avertissement indiquant que la taille de votre disque est inférieure à 200 Go peut s'afficher. Vous pouvez ignorer cet avertissement.

Installer le proxy NFS sur le client NFS

Au cours de cette étape, vous allez ouvrir une session SSH distincte sur votre client NFS, puis installer le proxy NFS. Vous utiliserez cette même interface système pour tester le système dans la section suivante.

  1. Dans la console, accédez à la page Instances de VM.

    Accéder à la page "Instances de VM"

  2. Pour vous connecter à nfs-client, dans la colonne Connecter, cliquez sur SSH.

  3. Dans la fenêtre SSH nfs-client, installez les outils NFS nécessaires sur nfs-client :

    sudo apt-get install nfs-common -y
    
  4. Créez un point d'installation et installez le proxy NFS :

    sudo mkdir /data
    sudo mount -t nfs -o vers=3 nfs-proxy:/data /data
    

Tester le système

Toutes vos ressources sont maintenant créées. Dans cette section, vous allez exécuter un test en copiant un fichier du serveur NFS vers le client NFS via le proxy NFS. La première fois que vous exécutez ce test, les données proviennent du serveur d'origine. Cette opération peut prendre plus d'une minute.

La seconde fois que vous exécutez ce test, les données sont diffusées à partir d'un cache stocké dans les disques SSD locaux du proxy NFS. Dans ce transfert, la copie des données prend beaucoup moins de temps, ce qui confirme que la mise en cache accélère le transfert de données.

  1. Dans la fenêtre SSH nfs-client que vous avez ouverte dans la section précédente, copiez le fichier test et affichez le résultat correspondant :

    time dd if=/data/test.data of=/dev/null iflag=direct bs=1M status=progress
    

    Le résultat ressemble à ce qui suit, qui contient une ligne indiquant la taille du fichier, la durée de transfert et les vitesses de transfert :

    10737418240 bytes (11 GB, 10 GiB) copied, 88.5224 s, 121 MB/s
    real    1m28.533s
    

    Dans ce transfert, le fichier est diffusé à partir du disque persistant du serveur NFS. Il est donc limité par la vitesse du disque du serveur NFS.

  2. Exécutez la même commande une seconde fois :

    time dd if=/data/test.data of=/dev/null iflag=direct bs=1M status=progress
    

    Le résultat ressemble à ce qui suit, qui contient une ligne indiquant la taille du fichier, la durée de transfert et les vitesses de transfert :

    10737418240 bytes (11 GB, 10 GiB) copied, 9.41952 s, 948 MB/s
    real    0m9.423s
    

    Dans ce transfert, le fichier est diffusé à partir du cache du proxy NFS, ce qui accélère les opérations.

Vous avez terminé le déploiement et les tests du proxy de mise en cache KNFSD.

Rubriques avancées sur les workflows

Cette section comprend des informations sur le déploiement sur une architecture hybride, le scaling pour des performances élevées, ainsi que l'utilisation de métriques et de tableaux de bord pour le dépannage et le réglage.

Caractéristiques des performances et dimensionnement des ressources

Comme indiqué précédemment, ce tutoriel utilise un seul proxy KNFSD. Par conséquent, le scaling du système implique de modifier vos ressources de proxy individuelles afin d'optimiser le processeur, la mémoire RAM, la mise en réseau, la capacité de stockage ou les performances. Dans ce tutoriel, vous avez déployé KNFSD sur une seule VM Compute Engine avec les options suivantes :

  • 16 processeurs virtuels, 104 Go de RAM (n1-highmem-16).
    • Avec 16 processeurs virtuels et une architecture Sandy Bridge ou ultérieure, vous obtenez une vitesse de mise en réseau maximale de 32 Gbit/s.
  • Disque persistant de 10 Go en tant que disque de démarrage
  • 4 disques SSD locaux. Cette configuration fournit un système de fichiers haut débit de 1, 5 To.

Bien que cela n'entre pas dans le cadre de ce tutoriel, vous pouvez faire évoluer cette architecture en créant plusieurs proxys KNFSD dans un MIG et en utilisant un équilibreur de charge TCP pour gérer les connexions entre les clients NFS et les proxys NFS. Pour plus d'informations, consultez le dépôt GitHub knfsd-cache-utils qui contient des scripts Terraform, un exemple de code pour le déploiement et diverses questions fréquentes sur le scaling des charges de travail.

Éléments à prendre en compte pour un déploiement hybride

Dans de nombreux déploiements, la bande passante de votre connexion sur site vers le cloud est un facteur important à prendre en compte lors de la configuration du système. La connectivité hybride dépasse le cadre de ce tutoriel. Pour obtenir un aperçu des options disponibles, consultez la documentation sur la connectivité hybride. Pour obtenir des conseils sur les bonnes pratiques et les modèles de conception, consultez la série Modèles et pratiques hybrides et multicloud.

Explorer les métriques

Les tableaux de bord peuvent être utiles pour fournir des commentaires sur les métriques à utiliser dans le cadre du réglage des performances et du dépannage global. L'exploration de métriques dépasse le cadre de ce tutoriel. Toutefois, un tableau de bord des métriques est disponible lorsque vous déployez le système multinœud défini dans le dépôt GitHub knfsd-cache-utils.

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.

  1. Dans la console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étape suivante