it-swarm-eu.dev

Comment puis-je obtenir le nom de la distribution et le numéro de version dans un simple script Shell?

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"
200
Alix Axel

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.

194
Mikel

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.

59
Mat

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

37
sakisk

One-liner, repli, une ligne de sortie, pas d'erreurs.

( lsb_release -ds || cat /etc/*release || uname -om ) 2>/dev/null | head -n1
24
Markus
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])"
13
Ilya Kharlamov
  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

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
}  
9
Orwellophile

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
6
Chris Maes

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.

6
Eelvex

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.

3
Faheem Mitha

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
jsbillings

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.

1
Sam

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
0
Mithril

Sans version, juste seulement dist:

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

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
0
jturi

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}'
0
BsdHelper

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
0
user9869932

J'utilise screenfetch utilitaire de script:

enter image description here

0
Drakonoved

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
0
niceguy oh

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.