Blog

  • MultiThreading en BASH

    MultiThreading en BASH

    Comment faire du MultiThreading en BASH…. En fait c’est assez simple, il suffit des mettre les scripts en arrière-plan et d’attendre qu’ils soient terminés. Bien sûr, il peut exister certaines limitations…. C’est un non-sens de mettre 20 scripts en parallèle quand il n’y a que 4 processeurs….

    Donc pour gérer efficacement le multi-Threading », personnelemen,t je limite le nombre de threads au nombre de processeurs…..

    Voici une manière simple de gérer le multithreading :

    #--------------------------------------------------
    # Get the maximum physical Threads
    function JobMaxPhysicalThreads() {
            echo $(grep -c proc /proc/cpuinfo)
    }
    #--------------------------------------------------
    
    #--------------------------------------------------
    # Is Max Threads count reached ? If yes, wait....
    function JobOngoingThreads() {
        # How many jobs in Background now ?
        echo $(jobs|grep -vi "done"|wc -l)
    }
    #--------------------------------------------------
    
    #--------------------------------------------------
    # Is Max Threads count reached ? If yes, wait....
    function JobMaxThreadsReachedWait() {
        # How many jobs in Background now ?
        JobsInBackGround=$(JobOngoingThreads)
        # Is background processes limit reached ?
        if [[ $JobsInBackGround -gt $nThreadsLimit ]]; then
           # Wait until some slots are available
           while [[ $JobsInBackGround -gt $nThreadsLimit ]]
             do
               sleep 1
               JobsInBackGround=$(JobOngoingThreads)
             done
       fi
    }
    #--------------------------------------------------
    

    Dans le script lui-même avant d’envoyer un nouveau script en arrière-plan, il suffit de vérifier si le nombre de scripts en arrière-plan n’a pas atteint la limite, si oui, alors il suffit d’attendre qu’il y ait un slot de disponible…

    Par exemple :

    ## Check Current Number of Threads...in case, max is reached, wait !
    JobMaxThreadsReachedWait
    ## Launch next Thread
    LaunchNewScript
    

     

  • Comment déterminer le nombre maximum de threads physiques ?

    Comment déterminer le nombre maximum de threads physiques ?

    Lorsque l’on veut faire du multithreading, il faut avant tout savoir le nombre de processeurs disponibles. Plusieurs possibilités pour cela, mais la plus simple :

    echo $(grep -c proc /proc/cpuinfo)
    

     

  • Elasticsearch cluster statuses

    Elasticsearch cluster statuses

    Quick command :

    curl -X GET "localhost:9200/_cat/nodes?v=true&pretty"

     

  • Erreur « max virtual memory areas vm.max_map_count [65530] is too low, increase to at least [262144] » sous docker for Windows

    Erreur « max virtual memory areas vm.max_map_count [65530] is too low, increase to at least [262144] » sous docker for Windows

    Lors du démarrage d’Elasticsearch sous Docker Desktop, vous obtenez ce message d’erreur :

     max virtual memory areas vm.max_map_count [65530] is too low, increase to at least [262144]

    Un moyen simple et efficace pour fixer le problème est :

    C:\local\docker\elk>wsl -d docker-desktop
    WIN10LAPTOP:/mnt/host/c/local/docker/elk# sysctl -w vm.max_map_count=262144
    vm.max_map_count = 262144
    WIN10LAPTOP:/mnt/host/c/local/docker/elk# exit
    
    C:\local\docker\elk>

    Ces changements ne sont pas permanent. Après chaque boot, il faut les ré-exécuter. Je cherche un moyen pour les rendre permanent…

    La meilleure option est bien sûr de switcher vers Mac ou Linux. En effet pour ceux-ci, la procédure est bien plus professionelles….

     

  • Ajout de node dans swarm

    Ajout de node dans swarm

    Pour gérer un swarm, il faut, avant tout, obtenir le token…

    La syntax est :

    pi@pi4node001:~ $ docker swarm join-token
    "docker swarm join-token" requires exactly 1 argument.
    See 'docker swarm join-token --help'.
    
    Usage:  docker swarm join-token [OPTIONS] (worker|manager)
    
    Manage join tokens
    pi@pi4node001:~ $

    Donc quand on veut ajouter un node de type MANAGER :

    pi@pi4node001:~ $ docker swarm join-token manager
    To add a manager to this swarm, run the following command:
    
    docker swarm join --token SWMTKN-1-2kr5jo0trm2o9bvnypqlzizx1exxivfeitqzi9smnhv6gxsd0f-95rzv0a1mbp0f8k1xkg55176n 192.168.0.201:2377
    
    pi@pi4node001:~ $

    et pour un de type WORKER :

    pi@pi4node001:~ $ docker swarm join-token worker 
    To add a worker to this swarm, run the following command:
    
        docker swarm join --token SWMTKN-1-2kr5jo0trm2o9bvnypqlzizx1exxivfeitqzi9smnhv6gxsd0f-8agpq7585s28ppp6gu1ldkf2x 192.168.0.201:2377
    
    pi@pi4node001:~ $

    maintenant, il faut se connecter sur le node voulu et exécuter la commande ci-dessus (en fonction du rôle voulu).

    Voici un exemple de swarm :

    pi@pi4node001:~ $ docker node ls  
    ID                            HOSTNAME     STATUS    AVAILABILITY   MANAGER STATUS   ENGINE VERSION
    ppyfmhdq6p4xpflqj17eay2cm *   pi4node001   Ready     Active         Leader           20.10.5
    pwsktgnu30hvtx5zkgsz4ay2v     pi4node002   Ready     Active                          20.10.5
    pi@pi4node001:~ $

    Pour ajouter 2 noeuds de type WORKER (notez les hostnames… ):

    sur pi4node004:

    pi@pi4node004:~ $ docker swarm join --token SWMTKN-1-2kr5jo0trm2o9bvnypqlzizx1exxivfeitqzi9smnhv6gxsd0f-8agpq7585s28ppp6gu1ldkf2x 192.168.0.201:2377
    This node joined a swarm as a worker.
    pi@pi4node004:~ $ 
    

    sur pi4node003:

    pi@pi4node003:~ $ docker swarm join --token SWMTKN-1-2kr5jo0trm2o9bvnypqlzizx1exxivfeitqzi9smnhv6gxsd0f-8agpq7585s28ppp6gu1ldkf2x 192.168.0.201:2377 
    This node joined a swarm as a worker. 
    pi@pi4node003:~ $

    Le résultat est :

    pi@pi4node001:~ $ docker node ls
    ID                            HOSTNAME     STATUS    AVAILABILITY   MANAGER STATUS   ENGINE VERSION
    ppyfmhdq6p4xpflqj17eay2cm *   pi4node001   Ready     Active         Leader           20.10.5
    pwsktgnu30hvtx5zkgsz4ay2v     pi4node002   Ready     Active                          20.10.5
    ucelbnf80e6ledibr1qcy9znd     pi4node003   Ready     Active                          20.10.5
    awl41iytsw3me002o9gh6u96h     pi4node004   Ready     Active                          20.10.5
    pi@pi4node001:~ $ 
    

     

  • Article sans titre 48647

    Docker Swarm Visualizer – Interface Web

    [callout type= »tip » title= »Quick Win »]
    Déploie une interface web en une commande pour visualiser en temps réel l’état de ton cluster Docker Swarm.
    [/callout]

    Contexte

    Quand tu gères un cluster Docker Swarm multi-nœuds, il est essentiel d’avoir une vue d’ensemble de l’état des services et des conteneurs. Le Swarm Visualizer d’Alex Ellis fournit exactement ça.

    Installation

    [code lang= »bash » title= »deploy-visualizer.sh »]

    Vérifier l’état du cluster

    pi@pi4node001:~ $ docker node ls
    ID HOSTNAME STATUS AVAILABILITY MANAGER STATUS ENGINE VERSION
    ppyfmhdq6p4xpflqj17eay2cm * pi4node001 Ready Active Leader 20.10.5
    pwsktgnu30hvtx5zkgsz4ay2v pi4node002 Ready Active 20.10.5
    zmt3lly41a9ultipey0p42oor pi4node003 Ready Active 20.10.5
    ushbeebwkt20orsg29uhy8420 pi4node004 Ready Active 20.10.5

    Déployer le visualizer

    docker service create
    –name viz
    –publish 8080:8080/tcp
    –constraint node.role==manager
    –mount type=bind,src=/var/run/docker.sock,dst=/var/run/docker.sock
    alexellis2/visualizer-arm:latest

    Vérifier le déploiement

    docker service ls
    ID NAME MODE REPLICAS IMAGE PORTS
    ki6uzmz4myuu viz replicated 1/1 alexellis2/visualizer-arm:latest *:8080->8080/tcp
    [/code]

    [callout type= »note » title= »Architecture ARM »]
    Utilise alexellis2/visualizer-arm:latest pour Raspberry Pi. Pour x86, utilise dockersamples/visualizer.
    [/callout]

    Accès

    Une fois déployé, accède à l’interface via: http://IP_MANAGER:8080

    L’interface affiche en temps réel:

    • 📊 Tous les nœuds du cluster
    • 🐳 Les conteneurs sur chaque nœud
    • 📈 L’état des services
    • 🔄 Les mises à jour en live

    Performance

    [metrics before= »K3s: ~800MB RAM » after= »Swarm: ~200MB RAM » improvement= »+75% plus léger »]

    [callout type= »success »]
    Docker Swarm est significativement moins gourmand en ressources que K3s, ce qui est idéal pour des clusters Raspberry Pi.
    [/callout]

    Configuration Avancée

    Persistence des Données

    Pour sauvegarder l’état du visualizer:

    [code lang= »bash » title= »visualizer-with-volume.sh »]
    docker service create
    –name viz
    –publish 8080:8080/tcp
    –constraint node.role==manager
    –mount type=bind,src=/var/run/docker.sock,dst=/var/run/docker.sock
    –mount type=volume,src=viz-data,dst=/data
    alexellis2/visualizer-arm:latest
    [/code]

    Mise à Jour

    [code lang= »bash » title= »update-visualizer.sh »]

    Mettre à jour l’image

    docker service update
    –image alexellis2/visualizer-arm:latest
    viz

    Vérifier le rollout

    docker service ps viz
    [/code]

    Troubleshooting

    [callout type= »warning » title= »Service ne démarre pas »]
    Symptôme: Le service ne démarre pas ou redémarre en boucle.

    Solutions:

    1. Vérifier que Docker socket est accessible: ls -la /var/run/docker.sock
    2. Vérifier les logs: docker service logs viz
    3. S’assurer que le port 8080 est libre: netstat -tulpn | grep 8080
      [/callout]

      🔗 Ressources

      [resources]
      [resource type= »github » url= »https://github.com/alexellis/docker-swarm-visualiser »]Swarm Visualizer – GitHub[/resource]
      [resource type= »doc » url= »https://docs.docker.com/engine/swarm/ »]Docker Swarm Documentation[/resource]
      [resource type= »blog » url= »https://blog.alexellis.io/docker-swarm-visualizer/ »]Blog Post – Alex Ellis[/resource]
      [/resources]


      Métadonnées WordPress

      Difficulté: ⭐ (Débutant) Niveau: Beginner Temps d’implémentation: 5 min Production Ready:Catégories: Docker, Swarm, SRE, Observability URL originale: https://you.arewel.com/visualisation-du-swarm/

  • Ansible, Prometheus et Grafana installés et configurés…

    Ansible, Prometheus et Grafana installés et configurés…

    Ansible déployé en une commande :

    apt install ansible
    

    Voici l’inventaire des nodes utilisés dans ansible :

    Pour déployer grafana et prometheus via ansible, j’ai utilisé en partie le tutoriel de Dino Fizzotti avec quelques adaptations (tout n’était pas aussi simple), je ferai probablement un autre article  sur ce que j’ai changé.

    Le résultat après quelques troubleshooting et quelques modifications est que finalement grafana permet  de monitorer les différents nodes du cluster.

  • Montage du cluster

    Montage du cluster

    Commençons par le commencement : le montage du cluster.

    Pour chaque Raspberry Pi, je mets des dissipateurs de chaleur sur la mémoire et le CPU :

    J’ai opté pour un châssis acrylique à 4 niveaux avec ventilateurs à chaque étage très basique mais efficace… Allez ! C’est parti… Un peu comme un lego.. Niveau par niveau, ensuite connection des ventilateurs (si ce sont des 5V alors le fil Rouge sur le pin 4 et le fil Noir sur le pin 6, si 3.3V alors rouge sur pin 1 et Noir sur pin 9).

    Et voilà le résultat final :

    Maintenant le câblage (réseau et alimentation) :

     

    Voilà ! Le cluster est prêt pour l’allumage ! Reste à préparer les cartes MicroSD et commencer les configurations….Suite au prochain numéro….

  • Comment créer une carte SD de boot pour Raspberry Pi

    Comment créer une carte SD de boot pour Raspberry Pi

    Il existe plusieurs méthodes pour créer une carte SD de boot pour Raspberry Pi. La solution la plus simple et la plus rapide pour cela est d’utiliser « Raspberry Pi Imager« . Cette application existe pour MacOS, Windows et Ubuntu.

    Installation de Raspberry Pi Imager Install Raspberry Pi Imager
    Faites glisser l’icône du « Raspberry Pi Imager » dans « Applications » afin de l’installer sur votre Mac.
    Ecran principal de Raspberry Pi Imager Raspberry Pi main screen
    Sélection de l'image à transférer sur la carte SD Sélectionnez l’Operating System à copier sur la carte SD
    Sélectionnez l’image à transférer. Un grand choix est disponible.
    Sélection de la carte SD Sélectionnez la destination d’lécriture, les différentes cartes SD disponibles.
    Attention tout le contenu de la carte SD sera effacé. Confirmation de l’eefacement des données potentiellement contenues sur la carte SD
    Ecriture de l'image sur la carte SD en cours Ecriture de l’image de l’operating system sur la carte SD en cours
    Vérification de la carte SD Vérification de l’Operating System transféré sur la carte SD
    Carte SD est prête à l'usage Confirmation que tout s’est bien déroulé et que la carte SD est prête à être utilisée.
  • Ils sont arrivés !

    Ils sont arrivés !

    Les voilà ! Je pense que je vais pouvoir jouer avec la semaine qui vient…. Je prévois de faire une série d’articles sur eux via la création d’un cluster, l’installation de kubernetes, …