Catégorie : BASH

  • 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)
    

     

  • 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/

  • Comment trouver automatiquement tous les Raspberry’s sur le réseau ?

    Comment trouver automatiquement tous les Raspberry’s sur le réseau ?

    Une adresse MAC (Medium Access Control ou contrôle d’accès au support) est un « numéro de série » unique affecté à chaque matériel du réseau Ethernet destiné à l’identifier dans un réseau. Cette adresse unique est attribuée par le fabricant à la fabrication du matériel.

    Chaque fabricant est également identifié d’une manière unique. La liste des identifiants est mise à jour régulièrement et est disponible sur le web.

    En utilisant une combinaison de commandes très simples, on peut donc déterminer le(s) fabricant(s) d’un élément réseau connecté à votre réseau !

    Récupération des identifiants utilisés dans les adresses MAC :

    curl https://devtools360.com/en/macaddress/vendorMacs.xml?download=true 
    

    Exemple :

    youarewelcom@myhost : ~/Raspberry > curl https://devtools360.com/en/macaddress/vendorMacs.xml?download=true 2>/dev/null | tail 
    <VendorMapping mac_prefix="FC:F7:7B" vendor_name="Huawei Device Co., Ltd."/>
    <VendorMapping mac_prefix="FC:F8:AE" vendor_name="Intel Corporate"/>
    <VendorMapping mac_prefix="FC:F8:B7" vendor_name="TRONTEQ Electronic"/>
    <VendorMapping mac_prefix="FC:FA:F7" vendor_name="Shanghai Baud Data Communication Co.,Ltd."/>
    <VendorMapping mac_prefix="FC:FB:FB" vendor_name="Cisco Systems, Inc"/>
    <VendorMapping mac_prefix="FC:FC:48" vendor_name="Apple, Inc."/>
    <VendorMapping mac_prefix="FC:FE:77" vendor_name="Hitachi Reftechno, Inc."/>
    <VendorMapping mac_prefix="FC:FE:C2" vendor_name="Invensys Controls UK Limited"/>
    <VendorMapping mac_prefix="FC:FF:AA" vendor_name="IEEE Registration Authority"/>
    </MacAddressVendorMappings>
    youarewelcom@myhost : ~/Raspberry >

    Extraire uniquement les lignes pour Raspberry  :

    curl https://devtools360.com/en/macaddress/vendorMacs.xml?download=true 2>/dev/null | grep -i Raspberry

    Exemple:

    youarewelcom@myhost : ~/Raspberry > curl https://devtools360.com/en/macaddress/vendorMacs.xml?download=true 2>/dev/null | grep -i Raspberry
    <VendorMapping mac_prefix="3A:35:41" vendor_name="Raspberry Pi (Trading) Ltd"/>
    <VendorMapping mac_prefix="B8:27:EB" vendor_name="Raspberry Pi Foundation"/>
    <VendorMapping mac_prefix="DC:A6:32" vendor_name="Raspberry Pi Trading Ltd"/>
    <VendorMapping mac_prefix="E4:5F:01" vendor_name="Raspberry Pi Trading Ltd"/>
    youarewelcom@myhost : ~/Raspberry >

    Récupérer les listes des périphériques réseau :

    La commande « nmap » permet d’explorer une réseau et de trouver les différents périphériques connectés au réseau.

    youarewelcom@myhost : ~/Raspberry > sudo nmap -sP 192.168.0.0/24 | head
    Starting Nmap 7.91 ( https://nmap.org ) at 2021-04-03 15:42 CEST
    Nmap scan report for xxxxxxxxx (192.168.0.1)
    Host is up (0.0059s latency).
    MAC Address: D4:5D:64:0E:C9:98 (Asustek Computer)
    Nmap scan report for yyyyyyyyy (192.168.0.15)
    Host is up (0.34s latency).
    MAC Address: 14:88:E6:80:20:67 (Unknown)
    Nmap scan report for zzzzzzzz (192.168.0.18)
    Host is up (0.24s latency).
    MAC Address: 0A:B2:56:90:50:8A (Unknown)
    youarewelcom@myhost : ~/Raspberry >

    Il suffit d’utiliser cet utilitaire combiné à quelques commandes pour obtenir de manière simple l’ensemble des Raspberry’s présent sur le réseau :

    # Retrieve the MAC Addresses prefixes for Raspberry
    curl https://devtools360.com/en/macaddress/vendorMacs.xml?download=true 2>/dev/null | grep -i Raspberry|awk -F\" '{ print $2 }' >Raspberry.MacPrefix.txt
    
    # Scan the network to find the different devices (IP and MAC Address)
    nmap -sP 192.168.0.0/24 | awk '/Nmap scan report for/{printf $5" "$6;}/MAC Address:/{print " "$3;}' | sort|grep -f Raspberry.MacPrefix.txt |sed 's/[\(\)]//g'

    Exemple d’une manière de déterminer le hostname, l’ip et l’adresse MAC des Raspberry’s sur le réseau 192.168.0.0/24 :

    youarewelcom@myhost : ~/Raspberry > curl https://devtools360.com/en/macaddress/vendorMacs.xml\?download\=true 2>/dev/null | grep -i Raspberry|awk -F\" '{ print $2 }' >Raspberry.MacPrefix.txt
    youarewelcom@myhost : ~/Raspberry > sudo nmap -sP 192.168.0.0/24 | awk '/Nmap scan report for/{printf $5" "$6;}/MAC Address:/{print " "$3;}' | sort|grep -f Raspberry.MacPrefix.txt |sed 's/[\(\)]//g'
    192.168.0.200 DC:A6:32:E6:FB:7C
    192.168.0.201 E4:5F:01:04:38:61
    192.168.0.202 E4:5F:01:04:37:17
    192.168.0.203 E4:5F:01:04:38:55
    192.168.0.204 E4:5F:01:04:38:0D
    youarewelcom@myhost : ~/Raspberry >

    Si vous avez un DNS ou que vous avez adapté votre ‘/etc/hosts’, vous obtiendrez :

    youarewelcom@myhost : ~/Raspberry >  sudo nmap -sP 192.168.0.0/24 | awk '/Nmap scan report for/{printf $5" "$6;}/MAC Address:/{print " "$3;}' | sort|grep -f Raspberry.MacPrefix.txt |sed 's/[\(\)]//g'
    pi4node000 192.168.0.200 DC:A6:32:E6:FB:7C
    pi4node001 192.168.0.201 E4:5F:01:04:38:61
    pi4node002 192.168.0.202 E4:5F:01:04:37:17
    pi4node003 192.168.0.203 E4:5F:01:04:38:55
    pi4node004 192.168.0.204 E4:5F:01:04:38:0D
    youarewelcom@myhost : ~/Raspberry >

    Cela sera très utile pour ansible