Inwentaryzacja serwerów dedykowanych

Inwentaryzacja serwera dedykowanego – system Windows

Aby wykonać inwentaryzację serwera dedykowanego na systemie Windows:

  1. Pobierz skrypt dostępny pod adresem: https://homecloud.pl/support/collect.ps1
  2. Umieść pobrany skrypt na serwerze i uruchom go za pośrednictwem PowerShell’a.
  3. Wyświetlony wynik wyślij jako tekst na adres e-mail: info@homecloud.pl.
WAŻNE! Zalecamy, aby wynik wykonanej inwentaryzacji serwera dedykowanego został umieszczony w pliku tekstowym i następnie wysłany w formie załącznika na adres e-mail: info@homecloud.pl. W wiadomości e-mail wysłanej do homecloud.pl oprócz dodanego pliku z wynikiem inwentaryzacji, prosimy o wskazanie ID subskrypcji, której inwentaryzacja dotyczy.
WAŻNE! Jeśli nie chcesz pobierać pliku collect.ps1, to możesz go utworzyć na serwerze samodzielnie. Kliknij tutaj, aby skopiować kod skryptu służącego do inwentaryzacji serwera dedykowanego na systemie Windows.

Inwentaryzacja serwera dedykowanego – system Linux

Aby wykonać inwentaryzację serwera dedykowanego na systemie Linux niezbędne będzie zainstalowanie poniższych binarek:

  • dmidecode
  • smartctl

Dodatkowo jeżeli posiadasz kontroler raid potrzebne będą dodatkowe binarki:

  • MegaCli64 (LSI/Avago)
  • hpacucli (HP p410)
  • tw_cli (3Ware)
  • megactl (SCSI)

Jak wykonać inwentaryzacje serwera dedykowanego CentOS (system Linux)?

  1. Zainstaluj niezbędne binarki za pomocą polecenia: 
    yum install dmidecode smartmontools
  2. Po wykonaniu polecenia, pojawi się informacja o instalowanej paczce. Wybieramy klawisz: „y” i przechodzimy do instalacji.
  3. Po zakończeniu instalacji, zostanie wyświetlony komunikat: Complete!
  4. Aby uruchomić skrypt do inwentaryzacji niezbędne jest zainstalowanie modułu PERL. Instalację modułu PERL wykonasz za pomocą polecenia: 
    yum install perl
  5. Po zainstalowaniu modułu PERL, należy pobierać skrypt, który umożliwi przeprowadzenie inwentaryzacji. Pobranie skryptu wykonaj za pomocą poniższego polecenia: 
    wget https://homecloud.pl/support/collect.pl
  6. Następnie uruchom skrypt wpisując w konsoli poniższe polecenie: 
    perl collect.pl
  7. Efektem powyższego polecenia, będzie wykonana inwentaryzacja serwera dedykowanego. Na ekranie w konsoli powinieneś otrzymać podobny wynik jak poniższy:
  8. Skopiuj wynik i wyślij jako tekst na adres e-mail: info@homecloud.pl.
WAŻNE! Zalecamy, aby wynik wykonanej inwentaryzacji serwera dedykowanego został umieszczony w pliku tekstowym i następnie wysłany w formie załącznika na adres e-mail: info@homecloud.pl. W wiadomości e-mail wysłanej do homecloud.pl oprócz dodanego pliku z wynikiem inwentaryzacji, prosimy o wskazanie ID subskrypcji, której inwentaryzacja dotyczy.
WAŻNE! Jeśli nie chcesz pobierać pliku collect.pl, to możesz go utworzyć na serwerze samodzielnie. Kliknij tutaj, aby skopiować kod skryptu służącego do inwentaryzacji serwera dedykowanego na systemie Windows.

 

Skrypt do inwentaryzacji serwerów dedykowanych – system Windows

Poniżej znajdziesz skrypt, którego możesz samodzielnie skopiować i następnie utworzyć plik (collect.ps1) na swoim serwerze dedykowanym. Przydatne dla użytkowników, którzy nie chcą pobierać pliku collect.ps1, lecz wolą utworzyć go samodzielnie na swoim serwerze dedykowanym.

$tmp = Get-WmiObject Win32_BaseBoard
foreach($device in $tmp){
  Write-Host "BoardName              : " $device.Name
  Write-Host "BoardManufacturer      : " $device.Manufacturer
  Write-Host "BoardProduct           : " $device.Product
  Write-Host "BoardSerial            : " $device.SerialNumber
}
$tmp = Get-WmiObject win32_bios
foreach($device in $tmp){
  Write-Host "BIOSName               : " $device.Name
  Write-Host "BIOSManufacturer       : " $device.Manufacturer
  Write-Host "BIOSVersion            : " $device.BIOSVersion
  Write-Host "BIOSReleaseDate        : " $device.ReleaseDate
  Write-Host "BIOSVersionSM          : " $device.SMBIOSBIOSVersion
}
$tmp = Get-WmiObject Win32_ComputerSystemProduct
foreach($device in $tmp){
  Write-Host "SystemVendor           : " $device.Vendor
  Write-Host "SystemVersion          : " $device.Version
  Write-Host "SystemName             : " $device.Name
  Write-Host "SystemID               : " $device.IdentifyingNumber
}
$tmp = Get-WmiObject win32_diskDrive
foreach($device in $tmp){
  Write-Host "DiskDrive              : " $device.Model
  Write-Host "DiskSerial             : " $device.SerialNumber
  Write-Host "DiskInterface          : " $device.InterfaceType
  Write-Host  -NoNewLine "DiskSize               : "; " {0:N2}" -f ($device.Size/1Gb) + " Gb"
}
$tmp = Get-WmiObject Win32_PhysicalMemory
foreach($device in $tmp){
    Write-Host  -NoNewLine "MemorySize             : "; " {0:N2}" -f ($device.Capacity/1Gb) + " Gb"
  Write-Host "MemoryManufacturer     : " $device.Manufacturer
  Write-Host "MemoryPartNumber       : " $device.PartNumber
  Write-Host "MemorySerialNumber     : " $device.SerialNumber
}
$tmp = Get-WmiObject Win32_Processor
foreach($device in $tmp){
  Write-Host "ProcessorID            : " $device.DeviceID
  Write-Host "ProcessorName          : " $device.Name
  Write-Host "ProcessorSpeed         : " $device.CurrentClockSpeed
  Write-Host "ProcessorCores         : " $device.NumberOfCores
  Write-Host "ProcessorLogical       : " $device.NumberOfLogicalProcessors
}
$tmp = Get-WmiObject Win32_SystemEnclosure
foreach($device in $tmp){
  Write-Host "EnclousureTag          : " $device.Tag
  Write-Host "EnclousurePartNumber   : " $device.PartNumber
  Write-Host "EnclousureSerialNumber : " $device.SerialNumber
}

 

Skrypt do inwentaryzacji serwerów dedykowanych – system Linux

Poniżej znajdziesz skrypt, którego możesz samodzielnie skopiować i następnie utworzyć plik (collect.pl) na swoim serwerze dedykowanym. Przydatne dla użytkowników, którzy nie chcą pobierać pliku collect.pl, lecz wolą utworzyć go samodzielnie na swoim serwerze dedykowanym.

#!/usr/bin/perl

use strict;
use warnings;

my $dmidecode = "dmidecode";
my $megacli   = "MegaCli64";
my $megactl   = "megactl";
my $hpacucli  = "hpacucli";
my $twcli     = "tw_cli";
my $smartctl  = "smartctl" ;

# ubuntu/debian : apt install dmidecode smartmontools
# centos        : yum install dmidecode smartmontools

my ( @tmp, @bios, @board, @chassis, @cpu, @memory, @storage, @raid, @cache, @bbu, @disks );
my ( %cpu_h, %memory_h );

foreach (`$dmidecode -t 0 2>/dev/null`) {
  push(@bios,$1) if /Vendor:\s+(.+?)\s+$/;
  push(@bios,$1) if /Version:\s+(.+?)\s+$/;
  push(@bios,$1) if /Release Date:\s+(.+?)\s+$/;
}

foreach (`$dmidecode -t 1 2>/dev/null`) {
  push(@chassis,$1) if /Manufacturer:\s+(.+?)\s+$/;
  push(@chassis,$1) if /Product Name:\s+(.+?)\s+$/;
  push(@chassis,$1) if /Serial Number:\s+(.+?)\s+$/;
}

foreach (`$dmidecode -t 2 2>/dev/null`) {
  push(@board,$1) if /Manufacturer:\s+(.+?)\s+$/;
  push(@board,$1) if /Product Name:\s+(.+?)\s+$/;
  push(@board,$1) if /Serial Number:\s+(.+?)\s+$/;
}

my ($cpu_model, $cpu_id);
foreach (`cat /proc/cpuinfo 2>/dev/null`) {
  $cpu_model = $1 if /^model name\s+:\s+(.+?)\s+$/;
  $cpu_id = $1 if /^physical id\s+:\s+(\d+)\s+$/;
  if (defined($cpu_model) && defined($cpu_id)) {
    $cpu[$cpu_id] = $cpu_model;
    undef($cpu_model);
    undef($cpu_id);
  }
}

my ($mem_size, $mem_type, $mem_speed);
foreach (`$dmidecode -t 17 2>/dev/null`) {
  $mem_size  = $1 if /^\s+Size:\s+(.+?)\s+$/ && ! /No Module Installed/;
  $mem_type  = $1 if /^\s+Type:\s+(.+?)\s+$/ && ! /Unknown/;
  $mem_speed = $1 if /^\s+Speed:\s+(.+?)\s+$/ && ! /Unknown/;
  if (defined($mem_size) && defined($mem_type) && defined($mem_speed)) {
    push(@memory,$mem_size." ".$mem_type." ".$mem_speed);
    undef($mem_size);
    undef($mem_type);
    undef($mem_speed);
  }
}

my @files;
my $dirname = '/sys/bus/scsi/devices/';
if (-d $dirname) {
  if (opendir (my($dh), $dirname)) {
    @files = grep { !/^\./ } readdir $dh;
    closedir $dh;
  }
}

foreach (@files) {
  my $filename = "/sys/bus/scsi/devices/$_/vendor";
  if (-f $filename) {
    if (open(my $fh, '<:encoding(UTF-8)', $filename)) {
      while (my $row = <$fh>) {
        chomp $row;
        $row =~ s/^\s+|\s+$//g;
        push(@storage,$row);
      }
    }
  }
}

my @u_storage = do { my %seen; grep { !$seen{$_}++ } @storage };

my ( $raid_model, $raid_serial );
my ( $disk_model, $disk_size, $disk_serial, $disk_type );
my %tc = ( "MegaRAID" => 0, "3Ware" => 0, "LSI" => 0, "HP" => 0, "SATA" => 0 );

foreach my $type (@u_storage) {
  chomp($type);
  # MegaRAID (SCSI)
  if ($type eq "MegaRAID" && $tc{'MegaRAID'} == 0) {
    print "No $megactl command available!\n" unless (`which $megactl 2>/dev/null`);
    @tmp = `$megactl 2>/dev/null`;
    foreach (@tmp) {
      push(@raid,$1.";") if  (/a\d+\s+(.+?)\s+chan:\d+\s+ldrv:\d+\s+batt/);
      push(@disks,"SCSI ".$1.";") if (/a\d+c\d+t\d+\s+(.+?)\s+a\d+d\d+/);
    }
    $tc{'MegaRAID'} = 1;
  }
  # 3ware
  if ($type eq "AMCC" && $tc{'3Ware'} == 0) {
    print "No $twcli command available!\n" unless (`which $twcli 2>/dev/null`);
    @tmp = `$twcli info 2>/dev/null`;
    my @c;
    my @p;
    foreach (@tmp) {
      push(@c,$1) if ($_ =~ /^(c[0-9]+).*/);
    }
    foreach my $c (@c) {
      @tmp = `$twcli /$c/bbu show all 2>/dev/null`;
      foreach (@tmp) {
        push(@bbu,";".$1) if ($_ =~ /Serial Number\s+=\s(\w+)/);
      }
      @tmp = `$twcli /$c show all 2>/dev/null`;
      foreach (@tmp) {
        $raid_model = $1 if ($_ =~ /Model\s+=\s(\w+)/);
        $raid_serial = $1 if ($_ =~ /Serial Number\s+=\s(\w+)/);
        if (defined($raid_model) && defined($raid_serial)) {
          push(@raid,$raid_model.";".$raid_serial);
          undef($raid_model);
          undef($raid_serial);
        }
        push(@p,$1) if ($_ =~ /^(p[0-9]+).*/);
      }
      foreach my $p (@p) {
        foreach (`$twcli /$c/$p show all 2>/dev/null`) {
          $disk_model = $1 if ($_ =~ /.*Model\s+=\s+(.*)/);
          $disk_serial = $1 if ($_ =~ /.*Serial\s+=\s+(.*)/);
          $disk_size = $1 if ($_ =~ /.*Capacity\s+=\s+(.+?)\s+\(/);
          $disk_type = $1 if ($_ =~ /.*Drive Type\s+=\s+(.*)/);
          $disk_type = 'SATA' if (!$disk_type);
          if (defined($disk_model) && defined($disk_serial) && defined($disk_size) && defined($disk_type)) {
            push (@disks,"3WARE ".$disk_size." ".$disk_type." ".$disk_model.";".$disk_serial);
            undef($disk_model);
            undef($disk_serial);
            undef($disk_size);
            undef($disk_type);
          }
        }
      }
    }
    $tc{'3Ware'} = 1;
  }
  # LSI
  if ($type =~ "LSI|INTEL|SMC|AVAGO" && $tc{'LSI'} == 0) {
    print "No $megacli command available!\n" unless (`which $megacli 2>/dev/null`);
    foreach (`$megacli -PDlist -Aall 2>/dev/null`) {
      $disk_model = $1 if (/^Inquiry Data:\s+(\w+)\s+(\w+)\s+(\w+)\s+$/);
      $disk_model = $2 if (/^Inquiry Data:\s+([a-zA-Z0-9-]+)\s+([a-zA-Z0-9.]+)\s+$/);
      $disk_model = $2 if (/^Inquiry Data:\s+(\w+)\s+(\w+)\s+(\w+)\s+(\w+)\s+$/);
      $disk_serial = $3 if (/^Inquiry Data:\s+(\w+)\s+(\w+)\s+(\w+)\s+$/);
      $disk_serial = $1 if (/^Inquiry Data:\s+([a-zA-Z0-9-]+)\s+([a-zA-Z0-9.]+)\s+$/);
      $disk_serial = $1 if (/^Inquiry Data:\s+(\w+)\s+(\w+)\s+(\w+)\s+(\w+)\s+$/);
      $disk_size = $1 if ($_ =~ /^Raw Size:\s+(.*)\s+\[/);
      $disk_type = $1 if ($_ =~ /^PD Type:\s+(.*)/);
      if (defined($disk_model) && defined($disk_serial) && defined($disk_size) && defined($disk_type)) {
        push (@disks,"LSI ".$disk_size." ".$disk_type." ".$disk_model.";".$disk_serial);
        undef($disk_model);
        undef($disk_serial);
        undef($disk_size);
        undef($disk_type);
      }
    }
    foreach (`$megacli -AdpAllInfo -aALL 2>/dev/null`) {
      $raid_model = $1 if /^Product Name\s+:\s+(.*)/;
      $raid_serial = $1 if /^Serial No\s+:\s+(\w+)/;
      if (defined($raid_model) && defined($raid_serial)) {
        push(@raid,$raid_model.";".$raid_serial);
        undef($raid_model);
        undef($raid_serial);
      }
    }
    foreach (`$megacli -AdpBbuCmd -aAll 2>/dev/null`) {
      push (@bbu,";".$1) if /Serial Number:\s+(\w+)/;
    }
    $tc{'LSI'} = 1;
  }
  # HP P410
  if ($type eq "HP" && $tc{'HP'} == 0) {
    print "No $hpacucli command available!\n" unless (`which $hpacucli 2>/dev/null`);
    my $raid_sn = 0;
    my $disk_sn = 0;
    foreach (`$hpacucli ctrl all show config detail 2>/dev/null`){
      $raid_sn = 1 if /^Smart Array/;
      $raid_sn = 0 if /^\s+physicaldrive/;
      $disk_sn = 1 if /^\s+physicaldrive/;
      $raid_model = $1 if /^Smart Array (.*) in Slot/;
      $raid_serial = $1 if ($_ =~ /^\s+Serial\s+Number:\s+(\w+)/ && $raid_sn == 1);
      if (defined($raid_model) && defined($raid_serial)) {
        push (@raid,$raid_model.";".$raid_serial);
        undef($raid_model);
        undef($raid_serial);
      }
      $disk_type = $1 if ($_ =~ /^\s+Interface\s+Type:\s+(\w+)/ && $disk_sn == 1);
      $disk_size = $1 if ($_ =~ /^\s+Size:\s+(.*)/ && $disk_sn == 1);
      $disk_serial = $1 if ($_ =~ /^\s+Serial\s+Number:\s+([\w-]+)/ && $disk_sn == 1);
      $disk_model = $2 if ($_ =~ /^\s+Model:\s+(\w+)\s+(.+?)\s+$/ && $disk_sn == 1);
      if (defined($disk_model) && defined($disk_serial) && defined($disk_size) && defined($disk_type)) {
        chomp($disk_model);
        push (@disks,"HP ".$disk_size." ".$disk_type." ".$disk_model.";".$disk_serial);
        undef($disk_model);
        undef($disk_serial);
        undef($disk_size);
        undef($disk_type);
      }
      push (@cache,";".$1) if ($_ =~ /^\s+Cache\s+Serial\s+Number:\s+(\w+)/ && $raid_sn == 1);
    }
    $tc{'HP'} = 1;
  }
  elsif ($tc{'SATA'} == 0) {
    print "No $smartctl command available!\n" unless (`which $smartctl 2>/dev/null`);
    foreach (`ls -1 /dev/sd* 2>/dev/null | grep -oE 'sd[a-z]+\$'`) {
      my $sd = $_ ;
      chomp($sd);
      foreach (`$smartctl -i /dev/$sd 2>/dev/null`) {
        $disk_model = $1 if ($_ =~ /Device\s+Model:\s+(.*)/i);
        $disk_model = $1 if ($_ =~ /Product:\s+(.*)/i);
        push (@disks,$disk_model.";".$1) if ($_ =~ /Serial\s+Number:\s+(.*)/i);
      }
    }
  }
  $tc{'SATA'} = 1;
}

my $host = `hostname -s`;
chomp($host);
print "\n";
print $host.";;bios"; print ";".$_ foreach (@bios); print ";\n";
print $host.";;chassis"; print ";".$_ foreach (@chassis); print ";\n";
print $host.";;board"; print ";".$_ foreach (@board); print ";\n";
print $host.";;cpu;".$_.";\n" foreach (@cpu);
print $host.";;memory;".$_.";\n" foreach (@memory);
print $host.";;controller;".$_.";\n" foreach (@raid);
print $host.";;cache;".$_.";\n" foreach (@cache);
print $host.";;battery;".$_.";\n" foreach (@bbu);
print $host.";;disk;".$_.";\n" foreach (@disks);
print "\n";
  • Czy artykuł był pomocny?
  • TAK   Nie