Quão urgente é necessária uma reinicialização do sistema *** por segurança?

Para aprender um pouco sobre administração de servidores, configurei um servidor Ubuntu 14.04 simples no qual administro um site pessoal. Eu o configurei para instalar automaticamente as atualizações de segurança, mas deixe de fora as outras atualizações. Isso parece funcionar muito bem. Ocasionalmente, recebo uma mensagem ao entrar no servidor (com ssh) dizendo:

*** System restart required ***

Nas vezes em que isso aconteceu, reiniciei o Ubuntu e tudo estava bem. Tudo bem, porque é um site pessoal simples. No entanto, o que me pergunto é como isso funciona para servidores da Web, que devem estar acima de 99.9999etc% do tempo? Eles simplesmente não reiniciam e correm o risco de a segurança ser violada porque as atualizações de segurança não estão instaladas (o que eu não consigo imaginar)? Ou eles tomam o tempo de inatividade como garantido (o que também não consigo imaginar)?

Como devo lidar com isso se esse era um servidor de produção muito importante que eu quero manter em funcionamento? Todas as dicas são bem-vindas!

[EDIT] Eu sei que posso fazer cat /var/run/reboot-required.pkgspara listar os pacotes que causam a reinicialização. O comando atualmente produz o seguinte:

linux-image-3.13.0-36-generic
linux-base
dbus
linux-image-extra-3.13.0-36-generic
linux-base

mas como sei se as atualizações são pequenas coisas sobre se tenho uma vulnerabilidade de segurança séria se não faço a reinicialização?

[EDIT2] Ok, agora eu combinei os comandos que achei úteis em um:

xargs aptitude changelog < /var/run/reboot-required.pkgs | grep urgency=high

Se isso não produzir nada, não parece haver problemas de segurança com alta urgência.

Uma última pergunta: são low, mediume highas únicas possibilidades de urgência, ou existem mais como por exemplo criticalou extremelyimportant?

A resposta não é simples, pois depende das atualizações feitas. Se o kernel teve um sério problema de segurança, é bom reiniciar o mais rápido possível. Se o kernel tiver apenas pequenas correções, o reinício poderá ser adiado.

Se você garantir uma disponibilidade> 99,9%, quase sempre terá um sistema em cluster no qual poderá reiniciar os nós um por um sem interromper o serviço.

Portanto, você reinicializa o primeiro sistema e o anexa novamente ao cluster. Depois o segundo e assim por diante. Em seguida, o serviço nunca ficará indisponível.

addon para a solução de tópicos

Realizo verificação semelhante para o 'requisito de reinicialização' do sistema de monitoramento zabbix

Vejo 2 problemas na solução 'Tópico':

1. O aptitude geralmente funciona mal em scripts. Eu mato algumas horas, mas ainda não o fiz funcionar com o zabbix
2. se apenas 1 registro de alterações incluir atualização urgente - sua verificação sempre mostrará resultados positivos

Minha lógica é:

1. Verifique a última alteração apenas no changelog para cada pacote que requer reinicialização do sistema
2. Como uma saída, mostre apenas a atualização de prioridade mais alta

Usando a documentação da Debian, encontrei 5 valores possíveis para 'urgency' e também o fato de que ele pode ser seguido por caracteres iguais ("=") ou ponto-e-vírgula (":"). Também pode haver caracteres maiúsculos e minúsculos

Então acabei com o seguinte:

#!/bin/bash
##################################
# Zabbix monitoring script
#
# Checking urgency in changelog 
# for updates which require system restart
#
##################################
# Contact:
#  [email protected]
##################################
# ChangeLog:
#  20151205    initial creation
#  20151208    check uniq packages only 
##################################

case "$1" in

status)
    if [ -f /var/run/reboot-required ]; then
      echo 1
    else
      echo 0
    fi 
    ;;

urgency)
    if [ -f /var/run/reboot-required.pkgs ]; then
      while read pkg; do
        tmp=`/usr/bin/apt-get changelog $pkg | \
             /bin/grep -m1 -ioP '(?<=[Uu]rgency[=:])(low|medium|high|emergency|critical)' | \
             tr '[:upper:]' '[:lower:]'`
        if [ -n $tmp ]; then
          if   [ "$tmp" == "low" ] && \
               [ "$urgency" != "medium" ] && \
               [ "$urgency" != "high" ] && \
               [ "$urgency" != "emergency" ] && \
               [ "$urgency" != "critical" ]; then 
            urgency=low
          elif [ "$tmp" == "medium" ] && \
               [ "$urgency" != "high" ] && \
               [ "$urgency" != "emergency" ] && \
               [ "$urgency" != "critical" ]; then 
            urgency=medium
          elif [ "$tmp" == "high" ] && \
               [ "$urgency" != "emergency" ] && \
               [ "$urgency" != "critical" ]; then 
            urgency=high
          elif [ "$tmp" == "emergency" ] && \
               [ "$urgency" != "critical" ]; then 
            urgency=emergency
          elif [ "$tmp" == "critical" ]; then 
            urgency=critical
            break
          fi
        fi 
      done < <(sort -u /run/reboot-required.pkgs)
    else
      urgency=none
    fi

    case "$urgency" in
        none)      urgency=0 ;;
        low)       urgency=1 ;;
        medium)    urgency=2 ;;
        high)      urgency=3 ;;
        emergency) urgency=4 ;;
        critical)  urgency=5 ;;
        *)         urgency=42 ;;
    esac

    echo $urgency
    ;;
esac
exit 0

Como um resultado:

• reboot_required_check.sh status retorna 1 se a reinicialização for necessária, 0 se não for
• reboot_required_check.sh urgency retorna o nível mais alto de 'urgência' ou '0' se a reinicialização não for necessária

Espero que ajude alguém a economizar um tempo;)

No entanto, o que me pergunto é como isso funciona para servidores da Web, que devem estar acima de 99.9999etc% do tempo? Eles simplesmente não reiniciam e correm o risco de a segurança ser violada porque as atualizações de segurança não estão instaladas (o que eu não consigo imaginar)? Ou eles tomam o tempo de inatividade como garantido (o que também não consigo imaginar)?

Grandes servidores web são reiniciados quando * Reinicialização do sistema necessária * aparece por motivos de segurança.

Mas isso é transparente para o usuário e o site nunca fica inativo porque os servidores grandes geralmente executam dois ou três servidores que armazenam exatamente os mesmos arquivos e exibem o mesmo site. O primeiro é o servidor principal, enquanto os outros dois são secundários e são usados ​​apenas quando o servidor principal está inativo.