Je travaille sur un simple script bash qui devrait pouvoir s'exécuter sur les distributions Ubuntu et CentOS (la prise en charge de Debian et 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, ce que j'ai, c'est ceci:
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 pour fonctionner, renvoyant ubuntu
ou centos
(je n'ai pas essayé d'autres) comme nom de version. Cependant, j'ai le sentiment qu'il doit y avoir un moyen plus simple et plus fiable de le découvrir - 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 OS
et VER
, la dernière norme semble être /etc/os-release
. Avant cela, il y avait lsb_release
et /etc/lsb-release
. Avant cela, vous deviez rechercher des fichiers différents pour chaque distribution.
Voici ce que je suggérerais
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 que uname
pour obtenir Arch
est toujours le meilleur moyen. Mais l'exemple que vous avez donné ne concerne évidemment que les systèmes Intel. Je l'appellerais soit BITS
comme ceci:
case $(uname -m) in
x86_64)
BITS=64
;;
i*86)
BITS=32
;;
*)
BITS=?
;;
esac
Ou changez Arch
pour être les versions les plus courantes, mais sans ambiguïté: x86
et x64
ou 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, cela dépend de vous.
J'irais avec cela comme une première étape:
ls /etc/*release
Gentoo, RedHat, Arch & SuSE ont un fichier appelé par ex. /etc/gentoo-release
. Semble être populaire, consultez ce site à propos de release-files .
Debian et Ubuntu devraient avoir un /etc/lsb-release
qui contient également des informations sur la version et apparaîtra avec la commande précédente.
Un autre rapide est uname -rv
. Si le noyau installé est le noyau de distribution stock, vous d'habitude trouve parfois le nom là-dedans.
lsb_release -a
. Fonctionne sur Debian et je suppose Ubuntu, 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'erreurs.
( lsb_release -ds || cat /etc/*release || uname -om ) 2>/dev/null | head -n1
python -m platform
exemples de sorties:
Ubuntu:
Linux-4.9.184-linuxkit-x86_64-with-Ubuntu-18.04-bionic
Debian:
Linux-4.14.117-grsec-grsec+-x86_64-with-debian-buster-sid
Centos:
Linux-3.10.0-957.1.3.el7.x86_64-x86_64-with-centos-7.6.1810-Core
Mac OS X:
Darwin-17.7.0-x86_64-i386-64bit
Voir documentation du module de plateforme si vous avez besoin d'une valeur spécifique de cette ligne. Par exemple, si vous avez uniquement besoin du nom de la distribution Linux, utilisez
python -c "import platform;print(platform.linux_distribution()[0])"
Suivez les conseils 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
}
Pour la plupart des systèmes d'exploitation Linux modernes, le fichier /etc/os-release
devient vraiment standard et est inclus dans la plupart des OS. Donc, à l'intérieur de votre script Bash, vous pouvez simplement inclure le fichier, et vous aurez accès à toutes les variables décrites ici (par exemple: NAME, VERSION, ...)
J'utilise donc ceci 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
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
couvrir la plupart des cas (AFAIK): Debian, Ubuntu, Slackware, Suse, Redhat, Gentoo, * BSD et peut-être d'autres.
Si le fichier /etc/debian_version
existe, la distribution est Debian ou un dérivé Debian. Ce fichier peut avoir un numéro de version; sur ma machine, il est actuellement 6.0.1
. S'il est en cours de test ou instable, il peut indiquer testing/unstable, ou il peut avoir le numéro de la prochaine version. Mon impression est que sur Ubuntu au moins, ce fichier est toujours en test/instable, et qu'ils n'y mettent pas le numéro de version, mais quelqu'un peut me corriger si je me trompe.
Fedora (versions récentes au moins), a 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 package), 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 parmi plusieurs:
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, c'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 très bien.
Je trouve un bon script d'ici qui fonctionne pour la plupart des dists linux courantes:
#! /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
Sans version, juste seulement dist:
cat /etc/issue | head -n +1 | awk '{print $1}'
Si quelqu'un a également 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
Production:
It is: 18.04
Passez à: 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
Production:
It is: bionic
Cela 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}'
Ce script fonctionne sur Debian, (peut-être besoin de 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
J'utilise screenfetch utilitaire de script:
#!/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
Il y a un facteur Ruby gem, qui vous donne quelques faits sur os OS, il analyse les fichiers de version du système d'exploitation, d'autres données et les imprime 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. Installez ensuite la gemme elle-même.
# gem install facter
Utilisez ensuite:
$ facter
REMARQUE: consultez les sources de gemmes facter pour obtenir plus d'informations sur l'installation.