Je travaille sur un script bash simple qui devrait pouvoir fonctionner sur les distributions Ubuntu et CentOS (la prise en charge de Debian et de Fedora / RHEL serait un plus) et j'ai besoin de connaître le nom et la version de la distribution que le script exécute ( afin de déclencher des actions spécifiques, par exemple la création de référentiels). Jusqu'à présent, voici ce que j'ai:

OS=$(awk '/DISTRIB_ID=/' /etc/*-release | sed 's/DISTRIB_ID=//' | tr '[:upper:]' '[:lower:]')
ARCH=$(uname -m | sed 's/x86_//;s/i[3-6]86/32/')
VERSION=$(awk '/DISTRIB_RELEASE=/' /etc/*-release | sed 's/DISTRIB_RELEASE=//' | sed 's/[.]0/./')

if [ -z "$OS" ]; then
    OS=$(awk '{print $1}' /etc/*-release | tr '[:upper:]' '[:lower:]')
fi

if [ -z "$VERSION" ]; then
    VERSION=$(awk '{print $3}' /etc/*-release)
fi

echo $OS
echo $ARCH
echo $VERSION

Cela semble fonctionner, revenir ubuntuou centos(je n'ai pas essayé d'autres) comme nom de version. Cependant, j’ai le sentiment qu’il doit exister un moyen plus facile et plus fiable de le savoir - est-ce vrai?

Cela ne fonctionne pas pour RedHat. / etc / redhat-release contient: Redhat Linux Entreprise version 5.5

Donc, la version n'est pas le troisième mot, vous feriez mieux d'utiliser:

OS_MAJOR_VERSION=`sed -rn 's/.*([0-9])\.[0-9].*/\1/p' /etc/redhat-release`
OS_MINOR_VERSION=`sed -rn 's/.*[0-9].([0-9]).*/\1/p' /etc/redhat-release`
echo "RedHat/CentOS $OS_MAJOR_VERSION.$OS_MINOR_VERSION"

Pour obtenir OSet VER, le dernier standard semble être /etc/os-release. Avant cela, il y avait lsb_releaseet /etc/lsb-release. Avant cela, vous deviez rechercher différents fichiers pour chaque distribution.

Voici ce que je suggère

if [ -f /etc/os-release ]; then
    # freedesktop.org and systemd
    . /etc/os-release
    OS=$NAME
    VER=$VERSION_ID
elif type lsb_release >/dev/null 2>&1; then
    # linuxbase.org
    OS=$(lsb_release -si)
    VER=$(lsb_release -sr)
elif [ -f /etc/lsb-release ]; then
    # For some versions of Debian/Ubuntu without lsb_release command
    . /etc/lsb-release
    OS=$DISTRIB_ID
    VER=$DISTRIB_RELEASE
elif [ -f /etc/debian_version ]; then
    # Older Debian/Ubuntu/etc.
    OS=Debian
    VER=$(cat /etc/debian_version)
elif [ -f /etc/SuSe-release ]; then
    # Older SuSE/etc.
    ...
elif [ -f /etc/redhat-release ]; then
    # Older Red Hat, CentOS, etc.
    ...
else
    # Fall back to uname, e.g. "Linux <version>", also works for BSD, etc.
    OS=$(uname -s)
    VER=$(uname -r)
fi

Je pense unameque ARCHc'est toujours le meilleur moyen d'obtenir. Mais l'exemple que vous avez donné ne traite évidemment que des systèmes Intel. Je l'appellerais soit BITScomme ça:

case $(uname -m) in
x86_64)
    BITS=64
    ;;
i*86)
    BITS=32
    ;;
*)
    BITS=?
    ;;
esac

Ou changer ARCHpour être les versions les plus courantes, mais sans ambiguïté: x86et x64ou similaire:

case $(uname -m) in
x86_64)
    ARCH=x64  # or AMD64 or Intel64 or whatever
    ;;
i*86)
    ARCH=x86  # or IA32 or Intel32 or whatever
    ;;
*)
    # leave ARCH as-is
    ;;
esac

mais bien sûr que ça vous regarde.

J'irais avec ceci dans un premier temps:

ls /etc/*release

Gentoo, RedHat, Arch & SuSE ont un fichier appelé par exemple /etc/gentoo-release. Semble être populaire, consultez ce site sur les fichiers de version .

Debian et Ubuntu devraient avoir un /etc/lsb-releasefichier contenant les informations de publication et s'afficheront avec la commande précédente.

Un autre rapide est uname -rv. Si le noyau installé est le noyau stock distro, vous habituellement trouverez parfois le nom là - dedans.

lsb_release -a. Fonctionne sur Debian et Ubuntu, je suppose, mais je ne suis pas sûr du reste. Normalement, il devrait exister dans toutes les distributions GNU / Linux car il est lié à LSB (Linux Standard Base).

One-Liner, repli, une ligne de sortie, pas d'erreur.

lsb_release -ds 2>/dev/null || cat /etc/*release 2>/dev/null | head -n1 || uname -om

python -c "import platform;print(platform.platform())"

ou juste

python -m platform

1. lsb- * n'est pas installé / n'existe pas sur les systèmes CentOS ou Debian de base
2. / proc / * n'existe pas sous OSX

Prenez un conseil des développeurs javascript. Ne testez pas la version, testez la capacité. Ce n'est pas joli, mais ça marche. Développez si nécessaire.

function os_type
{
case `uname` in
  Linux )
     LINUX=1
     which yum && { echo centos; return; }
     which zypper && { echo opensuse; return; }
     which apt-get && { echo debian; return; }
     ;;
  Darwin )
     DARWIN=1
     ;;
  * )
     # Handle AmgiaOS, CPM, and modified cable modems here.
     ;;
esac
}  

Par ordre de succès le plus probable, ceux-ci:

cat /etc/*version
cat /proc/version #linprocfs/version for FreeBSD when "linux" enabled
cat /etc/*release
uname -rv

autant que je sache (AFAIK): Debian, Ubuntu, Slackware, Suse, Redhat, Gentoo, * BSD et peut-être d’autres.

Pour la plupart des systèmes d'exploitation Linux modernes, le fichier /etc/os-releasedevient vraiment standard et est inclus dans la plupart des systèmes d'exploitation. Donc, dans votre script Bash, vous pouvez simplement inclure le fichier et vous aurez accès à toutes les variables décrites ici (par exemple: NOM, VERSION, ...)

Donc, je ne fais que l'utiliser dans mon script Bash:

if [ -f /etc/os-release ]
then
        . /etc/os-release
else
        echo "ERROR: I need the file /etc/os-release to determine what my distribution is..."
        # If you want, you can include older or distribution specific files here...
        exit
fi

Si le fichier /etc/debian_versionexiste, la distribution est Debian ou un dérivé de Debian. Ce fichier peut avoir un numéro de version; sur ma machine c'est actuellement 6.0.1. S'il teste ou est instable, il peut dire test / unstable ou le numéro de la prochaine version. Mon impression est que sur Ubuntu au moins, ce fichier est toujours en cours de test / instable, et qu’il n’y met pas le numéro de version, mais que quelqu'un puisse me corriger si je me trompe.

Fedora (au moins les versions récentes), ont un fichier similaire, à savoir /etc/fedora-release.

Si vous ne pouvez pas ou ne voulez pas utiliser le fichier de version LSB (en raison des dépendances apportées par le paquet), vous pouvez rechercher les fichiers de version spécifiques à la distribution. Bcfg2 a une sonde pour la distribution que vous pourriez utiliser: http://trac.mcs.anl.gov/projects/bcfg2/browser/doc/server/plugins/probes/group.txt

2 façons de beaucoup:

1) utiliser

lsb_release -a

Je l'ai testé sur CentOS 5.5 et Ubuntu 10.04

la sortie pour CentOS est:

LSB Version:    :core-3.1-ia32:core-3.1-noarch:graphics-3.1-ia32:graphics-3.1-noarch 
Distributor ID: CentOS
Description:    CentOS release 5.5 (Final)
Release:        5.5
Codename:       Final

et pour Ubuntu est:

LSB Version:    :core-3.1-ia32:core-3.1-noarch:graphics-3.1-ia32:graphics-3.1-noarch
Distributor ID: CentOS
Description:    CentOS release 5.5 (Final)
Release:        5.5
Codename:       Final

2) entrez la commande suivante:

cat /etc/*-release

Je l'ai testé sur CentOS 5.5 et Ubuntu 10.04, et cela fonctionne bien.

Ce script fonctionne sur Debian, (peut-être nécessiter quelques modifications sur Ubuntu)

#!/usr/bin/env bash

echo "Finding Debian/ Ubuntu Codename..."

CODENAME=`cat /etc/*-release | grep "VERSION="`
CODENAME=${CODENAME##*\(}
CODENAME=${CODENAME%%\)*}

echo "$CODENAME"
# => saucy, precise, lucid, wheezy, squeeze

Voici ma version simple de chech_distro. ^^;

#!/usr/bin/env bash
check_distro2(){
    if [[ -e /etc/redhat-release ]]
    then
      DISTRO=$(cat /etc/redhat-release)
    elif [[ -e /usr/bin/lsb_release ]]
    then
      DISTRO=$(lsb_release -d | awk -F ':' '{print $2}')
    elif [[ -e /etc/issue ]]
    then
      DISTRO=$(cat /etc/issue)
    else
      DISTRO=$(cat /proc/version)
    fi
    }

    check_distro2
    echo $DISTRO

Sans version, juste seulement dist:

cat /etc/issue | head -n +1 | awk '{print $1}'

Ceci a été testé sur Ubuntu 14 et CentOS 7

cat /etc/os-release | grep "PRETTY_NAME" | sed 's/PRETTY_NAME=//g' | sed 's/["]//g' | awk '{print $1}'

Je trouve un bon scénario d'ici qui fonctionne pour la plupart dists linux communs:

#! /bin/bash
# return an awkable string consisting of
#    unix OS type, or
#    Linux dist, or
#    a long guess (based on /proc), or
#    no clue

giveUp () {
   echo "Unknown"
   exit 0
}

# keep this easily awkable, prepending an initial clue
versionGuess () {
   if [ -e /proc/version ]; then
      echo -n "Unsure "
      cat /proc/version
      exit 0
   fi
   return 1
}

# if we have ignition, print and exit
gotDist () {
   [ -n "$1" ] && echo "$1" && exit 0
}

# we are only interested in a single word "dist" here
# various malformations can occur; admin will have to code appropately based on output
linuxRelease () {
   if [ -r /etc/lsb-release ]; then
      dist=$(grep 'DISTRIB_ID' /etc/lsb-release | sed 's/DISTRIB_ID=//' | head -1)
      gotDist "$dist"
   fi

   dist=$(find /etc/ -maxdepth 1 -name '*release' 2> /dev/null | sed 's/\/etc\///' | sed 's/-release//' | head -1)
   gotDist "$dist"

   dist=$(find /etc/ -maxdepth 1 -name '*version' 2> /dev/null | sed 's/\/etc\///' | sed 's/-version//' | head -1)
   gotDist "$dist"

   return 1
}

# start with uname and branch the decision from there
dist=$(uname -s 2> /dev/null)
if [ "$dist" = "Linux" ]; then
   linuxRelease
   versionGuess
   giveUp
elif [ -n "$dist" ]; then
   echo "$dist"
   exit 0
else
   versionGuess
   giveUp
fi

# we shouldn't get here
giveUp
# done

J'utilise l' utilitaire de script screenfetch :

Il existe une gemme ruby de faction , qui fournit des informations sur le système d’exploitation, analyse les fichiers de versions de système d’exploitation et d’autres données, puis les affiche sur l’écran du terminal. Vous pouvez essayer comme suit, en commençant par l’installation de rubygems:

# apt-get install rubygems

Veuillez utiliser le cas ci-dessus qui est éligible pour votre système d'exploitation. Ensuite, installez la gemme elle-même.

# gem install facter

Alors utilisez:

$ facter

REMARQUE: Voir les sources de gemmes du facteur pour obtenir plus d’informations lors de l’installation.

Si quelqu'un a aussi besoin de la distribution:

#!/usr/bin/env bash

LINUX_VERSION_NAME=`lsb_release -sr`


# Distribution specific installation
if [[ ${LINUX_VERSION_NAME} == "18.04" ]]
then
    echo "It is: ${LINUX_VERSION_NAME}"

else
    echo "It is not ${LINUX_VERSION_NAME}"
fi

Sortie:

It is: 18.04

Remplacez-le par: lsb_release -sc pour obtenir la distribution:

LINUX_VERSION_NAME=`lsb_release -sc`


# Distribution specific installation
if [[ ${LINUX_VERSION_NAME} == "bionic" ]]
then
    echo "It is: ${LINUX_VERSION_NAME}"

else
    echo "It is not ${LINUX_VERSION_NAME}"
fi

Sortie:

It is: bionic

Cette commande fonctionne pour les distributions basées sur Debian et Redhat: à l'aide d'un trfiltre, convertissez le document au format d'un mot par ligne, puis comptez la première ligne contenant le nom de la distribution.

tr -s ' \011' '\012' < /etc/issue | head -n 1