GNU/Linux >> Tutoriels Linux >  >> Linux

Quelles commandes sont disponibles dans la section %pre d'un fichier Kickstart sur CentOS ?

Le %pre section(s) de votre kickstart exécuté dans l'environnement du programme d'installation .

Voici une liste de commandes utiles disponibles dans l'environnement d'installation de RHEL6.5 :

  • Utilitaires Shell :arch awk basename bash cat chattr chgrp chmod chown chroot clear clock consoletype cp cut date df dmesg du echo egrep env expr false fgrep find getopt grep head hwclock id kill killall killall5 less ln ls lsattr mkdir mknod mktemp mv pidof ps pwd readlink rm rmdir sed sh shred sleep sort split sync tac tail tee top touch true tty uname uniq wc which xargs
  • Éditeurs et téléavertisseurs :less more vi
  • Utilitaires de hachage :md5sum sha1sum sha256sum
  • Compression et archivage :gzip bzip2 cpio dd tar rpm
  • fsck /mkfs /etc. pour ext2 ext3 ext4 xfs btrfs msdos vfat
  • Autres éléments du système de fichiers :mkswap swapon swapoff dmraid dmsetup mdadm mdmon dump restore mt lvm lvs vgs pvs ...
  • Utilitaires réseau :arp arping curl dhclient dhclient-script ftp ifconfig hostname ip ipcalc mtr nc ping rcp rdate rlogin telnet nslookup ntpdate route rsh rsync ssh ssh-keygen sshd scp sftp wget
  • Informations sur le matériel :biosdevname blkdeactivate blkid blockdev dmidecode lshal lspci lsscsi sginfo smartctl
  • Utilitaires de disque :eject dump restore hdparm smartctl losetup kpartx parted fdisk sfdisk
  • Gestion de la console/dialogues :chvt consolehelper openvt whiptail zenity
  • Journalisation :logger rsyslogd syslogd
  • python
  • Et bien plus !

Si vous exécutez une installation manuelle, vous pouvez passer au terminal sur VT2 (Ctrl Alt F2 ) et fouillez pour découvrir tout ce qui est disponible dans l'environnement du programme d'installation. compgen -c | sort -u est un moyen facile de lister toutes les commandes disponibles, et il y a beaucoup d'informations système à trouver dans /sys et /proc .

(Et oui, le kickstart est ré-analysé après le %pre les scripts s'exécutent, donc votre %pre peut modifier le kickstart et/ou générer de nouveaux extraits de kickstart à utiliser avec %include .)


De telles commandes ne sont généralement pas disponibles dans le %pre section de démarrage.

extrait - http://narrabilis.com/book/export/s5/6

%pre

La section %pre est l'endroit où vous pouvez spécifier les commandes à exécuter avant l'installation du système. Les commandes placées ici ne sont pas exécutées dans l'environnement d'installation chrooté. %pre doit venir à la fin du fichier kickstart. Vous pouvez ajouter --interpreter au %pre pour que le pré-script exécute un interpréteur différent de /bin/sh

La documentation de Fedora explique également ce qui est disponible dans %pre , dans la section Chapitre 4. Script de pré-installation de la documentation Anaconda/Kickstart.

extrait

Vous pouvez ajouter des commandes à exécuter sur le système immédiatement après l'analyse de ks.cfg et le traitement des options lang, keyboard et url. Cette section doit se trouver à la fin du fichier kickstart (après les commandes) et doit commencer par la commande %pre. Vous pouvez accéder au réseau dans la section %pre ; cependant, le service de noms n'a pas été configuré à ce stade, donc seules les adresses IP fonctionneront.

Enfin, les documents officiels de Red Hat ont ceci à dire, intitulé :32.6. Script de pré-installation :

La section de script de pré-installation de kickstart ne peut pas gérer plusieurs arborescences d'installation ou supports sources. Ces informations doivent être incluses pour chaque fichier ks.cfg créé, car le script de pré-installation se produit au cours de la deuxième étape du processus d'installation.

Vous aurez donc accès aux commandes incluses dans votre interpréteur (Bash, Python, etc.), mais rien d'autre.


Après avoir creusé un peu plus, j'ai trouvé une tonne d'informations système dans /proc qui est disponible pour la visualisation lorsque le %pre rubrique en ks.cfg exécute. Consultez dmidecode et les fichiers dans /proc pour obtenir toutes les informations dont vous avez besoin. Voici ce qui a fonctionné pour moi :

%pre --log=/tmp/ks_pre.log
  #!/bin/sh
  #----------------------------------------------
  # echos message to console screen and a log file
  #----------------------------------------------
  echo_screen_n_log() {
    msg=$1
    # Send to console screen
    (echo "$msg") >/dev/tty1
    # Send to log
    echo "$msg"
  }

  echo_screen_n_log ""
  echo_screen_n_log "Analyzing Hardware..."
  echo_screen_n_log ""

  #----------------------------------------------
  # System Memory
  #----------------------------------------------
  IFS=$'\n'
  mem_info=(`dmidecode --type memory`)
  unset IFS

  sys_mem_sizes=""
  sys_mem_banks=""
  sys_tot_mem=0
  cntr=0
  bank_cntr=0
  for i in "${mem_info[@]}"
  do
    # echo_screen_n_log "i: $i"
    # Maximum system memory that can be placed on the motherboard
    REG_EX="Maximum Capacity: (.*)$"
    if [[ $i =~ $REG_EX ]]
    then
      sys_mem_max=${BASH_REMATCH[1]} 
    fi
    # How many memory slots are on the motherboard
    REG_EX="Number Of Devices: (.*)$"
    if [[ $i =~ $REG_EX ]]
    then
      sys_mem_slots=${BASH_REMATCH[1]} 
    fi
    REG_EX="^[[:space:]]+Size: (.*)$"
    if [[ $i =~ $REG_EX ]]
    then
      sys_mem_sizes[cntr]=${BASH_REMATCH[1]}
      cntr=$(( $cntr + 1 ))
    fi
    REG_EX="^[[:space:]]+Bank Locator: (.*)$"
    if [[ $i =~ $REG_EX ]]
    then
      sys_mem_banks[bank_cntr]=${BASH_REMATCH[1]}
      bank_cntr=$(( $bank_cntr + 1 ))
    fi   
  done
  cntr=$(( $cntr - 1 ))
  echo_screen_n_log "Max system memory: $sys_mem_max"
  echo_screen_n_log "Total system slots: $sys_mem_slots"
  i=0
  while [ $i -le $cntr ]
  do
    echo_screen_n_log "Memory Bank Location ${sys_mem_banks[$i]} : ${sys_mem_sizes[$i]}"
    REG_EX="No Module Installed$"
    if [[ ! ${sys_mem_sizes[$i]} =~ $REG_EX ]]
    then
      REG_EX="^([0-9]+) [A-Z][A-Z]$"
      if [[ ${sys_mem_sizes[$i]} =~ $REG_EX ]]
      then
    sys_tot_mem=$(( $sys_tot_mem + ${BASH_REMATCH[1]} ))
      fi
    fi
    i=$(( $i + 1 ))
  done
  echo_screen_n_log "System Total Memory: $sys_tot_mem MB"

  #--------------------------------------------
  # Get Disk size information
  #--------------------------------------------
  IFS=$'\n'
  disk_info=(`cat /proc/partitions`)
  unset IFS

  total_disk_space=0
  type=""
  # Grab from minor column starting with 0 ending in 3 letters (drive node) 
  REG_EX="0\s+([0-9]+) [a-z][a-z][a-z]$"
  for i in "${disk_info[@]}"
  do
    # echo_screen_n_log "i: $i"
    if [[ $i =~ $REG_EX ]]
    then
      total_disk_space=${BASH_REMATCH[1]}
      total_disk_space=$(( $total_disk_space * 1024 ))
      type="GB"
      div_num=1000000000
      if [ "$total_disk_space" -lt $div_num ]
      then
        type="MB"
        div_num=1000000
      fi
      total_disk_space=$(( $total_disk_space / $div_num ))
    fi
  done
  echo_screen_n_log "Disk Space: $total_disk_space $type"

  #-----------------------------------------------------
  # Get CPU model name
  #-----------------------------------------------------
  cpu_grep=`grep 'model name' /proc/cpuinfo`
  cpu_model_nm="Not Found!"
  REG_EX="^.*: (.*)$"
  if [[ $cpu_grep =~ $REG_EX ]]
  then
    cpu_model_nm=${BASH_REMATCH[1]}
  fi
  echo_screen_n_log "CPU Model: $cpu_model_nm"

  #-------------------------------------------------------
  # Get number of physical CPUs
  #-------------------------------------------------------
  IFS=$'\n'
  cpu_count=(`grep "physical id" /proc/cpuinfo`)
  unset IFS

  last_cpu_id=""
  total_cpu_cnt=0
  # Add up all cores of the CPU to get total MIPS
  total_cpus=0
  REG_EX="^physical id\s+: ([0-9]+)$"
  for i in "${cpu_count[@]}"
  do
    # echo_screen_n_log "i: $i"
    if [[ $i =~ $REG_EX ]]
    then
  cpu_id=${BASH_REMATCH[1]}
      if [ ! "$last_cpu_id" = "$cpu_id" ]
      then
    total_cpu_cnt=$(( $total_cpu_cnt + 1 ))
    last_cpu_id=$cpu_id
  fi
    fi
  done
  echo_screen_n_log "System physical CPUs: $total_cpu_cnt"

  #-------------------------------------------------------
  # Get number of CPU cores
  #-------------------------------------------------------
  IFS=$'\n'
  cpu_cores=(`grep -m 1 "cpu cores" /proc/cpuinfo`)
  unset IFS

  total_cpu_cores=0
  REG_EX="^cpu cores\s+: ([0-9]+)$"
  for i in "${cpu_cores[@]}"
  do
    # echo_screen_n_log "i: $i"
    if [[ $i =~ $REG_EX ]]
    then
  total_cpu_cores=${BASH_REMATCH[1]}
    fi
  done
  echo_screen_n_log "CPU cores: $total_cpu_cores"

  #-------------------------------------------------------
  # CPU MHz
  #-------------------------------------------------------
  IFS=$'\n'
  dmi_cpu_MHz=(`dmidecode --string processor-frequency`)
  unset IFS

  cpu_MHz=0
  REG_EX="^[0-9]+ "
  for i in "${dmi_cpu_MHz[@]}"
  do
    # echo_screen_n_log "i: $i"
    if [[ $i =~ $REG_EX ]]
    then
  cpu_MHz=${BASH_REMATCH[1]}
    fi
  done
  echo_screen_n_log "CPU MHz: ${dmi_cpu_MHz:0:1}.${dmi_cpu_MHz:1:$(( ${#dmi_cpu_MHz} - 1 ))}"

  #-------------------------------------------------------
  # Get CPU bogomips (Millions of instructions per second)
  #-------------------------------------------------------
  IFS=$'\n'
  cpu_mips=(`grep "bogomips" /proc/cpuinfo`)
  unset IFS

  # Add up all cores of the CPU to get total MIPS
  total_mips=0
  REG_EX="\s([0-9]+)\..*$"
  for i in "${cpu_mips[@]}"
  do
    # echo_screen_n_log "i: $i"
    if [[ $i =~ $REG_EX ]]
    then
  cpu_bogomips=${BASH_REMATCH[1]}
      total_mips=$(( $total_mips + $cpu_bogomips ))
    fi
  done
  echo_screen_n_log "Total CPU MIPS (Millions of instructions per second) : $total_mips"

  echo_screen_n_log ""
  (echo -n "Press <enter> to continue..") >/dev/tty1
  read text
%end

J'ai juste besoin d'ajouter les critères pour déterminer à quoi devrait ressembler un système de base pour nos installations et j'ai terminé.....

Mise à jour avec plus d'informations... Vous pouvez également faire ce qui suit pour les informations sur le disque dans la section %pre :

IFS=$'\n'
parted_txt=(`parted -l`)
unset IFS

for i in "${parted_txt[@]}"
do
#    (echo "i: \"$i\"") >/dev/tty1
  REG_EX="^Model: (.*)$"
  if [[ $i =~ $REG_EX ]]
  then
    disk_model=${BASH_REMATCH[1]}
#      (echo "Disk Model: \"$disk_model\"") >/dev/tty1
  fi

  REG_EX="^Disk (.*): ([0-9]+).[0-9]([A-Z][A-Z])$"
  if [[ $i =~ $REG_EX ]]
  then
    disk_device=${BASH_REMATCH[1]}
    disk_capacity=${BASH_REMATCH[2]}
    disk_capacity_type=${BASH_REMATCH[3]}
    (echo "Device: \"$disk_device\"  \"$disk_capacity\"  $disk_capacity_type") >/dev/tty1
    IFS=$'\n'
    disk_txt=(`udevadm info --query=all --name=$disk_device`)
    unset IFS
     is_USB_drive=0
    for j in "${disk_txt[@]}"
    do
      #(echo "j: \"$j\"") >/dev/tty1
   REG_EX="^ID_BUS=usb$"
   if [[ $j =~ $REG_EX ]]
       then
     # USB keys are not to be included in total disk space
       #       (echo "$disk_device is a USB drive!") >/dev/tty1
        is_USB_drive=1
   fi
    done
    if [ "$is_USB_drive" = "0" ]
    then
   total_capacity=$(( $total_capacity + $disk_capacity ))
    fi
  fi
done

(echo "Disk Model: $disk_model") >/dev/tty1
(echo "Disk $disk_device Capacity: $total_capacity $disk_capacity_type") >/dev/tty1

Linux

  1. Que sont les séparateurs de mots Readline ?

  2. Quelles sont les utilisations légitimes de la commande "touch" ?

  3. Fedora vs Ubuntu :quelles sont les principales différences ?

  4. Que sont les fichiers fragmentés sous Linux

  5. Quel est le but du fichier .bashrc sous Linux

Que sont les inodes sous Linux ?

Quelles sont les différences entre grep, awk et sed ?

Quelle est la différence entre la section et le segment au format de fichier ELF

Installation des référentiels yum spécifiés dans le fichier kickstart

Quelles sont les commandes standard disponibles dans chaque distribution basée sur Linux ?

Quelles sont les différentes façons de définir les autorisations de fichiers, etc. sur gnu/linux