Durante o processo de operação e manutenção do servidor, geralmente é necessário monitorar vários recursos do servidor, como: monitoramento de carga da CPU, monitoramento do uso de disco, monitoramento do número de processos etc., de modo a alarmar imediatamente quando uma anormalidade ocorrer no sistema e notificar o administrador do sistema. Este artigo apresenta vários requisitos de monitoramento comuns e a redação de scripts de shell em sistemas Linux.
Diretório de artigos:
1.Linux usa Shell para verificar se o processo existe
2. Linux usa Shell para detectar a utilização de CPU do processo
3. Linux usa Shell para detectar o uso da memória do processo
4. Linux usa Shell para detectar o uso do processo
5.Linux usa Shell para ver se uma porta TCP ou UDP está ouvindo
6.Linux usa Shell para visualizar o número de processos em execução
7. Linux usa Shell para detectar a carga da CPU do sistema
8. Linux usa Shell para detectar o espaço do disco do sistema
9. Resumo
Verifique se o processo existe
Ao monitorar um processo, geralmente precisamos obter o ID do processo. O ID do processo é o identificador exclusivo do processo, mas às vezes vários processos com o mesmo nome do processo podem ser executados sob diferentes usuários no servidor. A função getPid abaixo fornece a função de obter o ID do processo do nome do processo especificado sob o usuário especificado (atualmente, apenas considerando iniciar um processo com esse nome de processo neste usuário). Possui dois parâmetros: o nome do usuário e o nome do processo. Primeiro, ele usa o PS para encontrar informações do processo e filtra o processo necessário através do Grep e, finalmente, encontra o valor de ID do processo através do SED e AWK (essa função pode ser modificada de acordo com condições reais, como filtrar outras informações etc.).
Listagem 1. Monitorando o processo
A cópia do código é a seguinte:
função getpid #user #name
{
Psuser = $ 1
Psname = $ 2
pid = `ps -u $ psusser | grep $ psname | grep -v grep | grep -v vi | grep -v dbx/n
| grep -v cauda | grep -v start | grep -v stop | sed -n 1p | awk '{print $ 1}' ``
eco $ pid
}
Demonstração de amostra:
1) Programa de origem (por exemplo, encontre o ID do processo do usuário como root e o nome do processo é cftestapp)
A cópia do código é a seguinte:
Pid = `getpid root cftestapp`
eco $ pid
2) Resultados Saída
A cópia do código é a seguinte:
11426
[dyu@xilinuxbldsrv shell] $
3) Análise de resultados
A partir da saída acima, podemos ver que 11426 é o ID do processo do programa CFTESTAPP sob o usuário root.
4) Introdução ao comando
1. PS: Veja as informações do processo instantâneo no sistema. Parâmetros: -u <Código de identificação do usuário> lista o status do programa pertencente ao usuário e também pode ser especificado usando o nome do usuário. -p <Código de identificação do processo> Especifique o código de identificação do processo e liste o status do processo. -O Especifique o formato de saída 2. Grep: usado para encontrar a linha atual no arquivo que corresponde à string. Parâmetros: -V Seleção reversa, ou seja, a linha que não mostra conteúdo 'string de pesquisa'. 3. SED: Um editor de texto não interativo que edita arquivos ou exportou arquivos da entrada padrão e só pode processar uma linha de conteúdo por vez. Parâmetros: -n Leia a próxima linha de entrada e use o próximo comando para processar a nova linha em vez do primeiro comando. P Impressões de sinalizador linhas correspondentes 4. Awk: uma linguagem de programação para processar texto e dados em Linux/Unix. Os dados podem ser de entrada padrão, um ou mais arquivos ou a saída de outros comandos. Ele suporta funções avançadas, como funções definidas pelo usuário e expressões regulares dinâmicas, e é uma poderosa ferramenta de programação no Linux/Unix. É usado na linha de comando, mas mais como um script. A maneira da AWK de processar o texto e os dados: digitaliza o arquivo passo a passo, da primeira linha para a última linha, procurando linhas de padrões específicos correspondentes e fazendo o que você deseja nessas linhas. Se nenhuma ação de processamento for especificada, as linhas correspondentes serão exibidas na saída padrão (tela). Se nenhum modo for especificado, todas as linhas especificadas pela operação serão processadas. Parâmetros: -f fs ou fs de separador de campo: especifica o delimitador de arquivo de entrada, o FS é uma string ou uma expressão regular, como -f:.
Às vezes, é possível que o processo não tenha começado. A seguinte função é verificar se o ID do processo existe. Se este processo não executar a saída:
A cópia do código é a seguinte:
O processo não existe.
# Verifique se o processo existe
Se ["-$ pid" == "-"]
Então
{
eco "o processo não existe".
}
fi
Detectar o processo de utilização da CPU
Ao manter os serviços de aplicativos, geralmente encontramos bloqueio de negócios devido à CPU excessiva, resultando em interrupção de negócios. Se a CPU estiver muito alta, pode ser devido a carga comercial excessiva ou ciclos anormais, como ciclos mortos. A CPU do processo de negócios é monitorada em tempo hábil através de scripts, e o pessoal de manutenção pode ser notificado em tempo hábil quando a utilização da CPU é anormal, para que o pessoal de manutenção possa ser analisado, posicionado e evitado de maneira prontamente analisada. A função a seguir pode obter a utilização da CPU do processo do ID do processo especificado. Possui um parâmetro como ID do processo. Primeiro, ele usa o PS para encontrar informações do processo, filtra %das linhas de CPU através do Grep -V e, finalmente, encontra a parte inteira da porcentagem de utilização da CPU através do AWK (se houver várias CPUs no sistema, a utilização da CPU pode exceder 100 %).
Listagem 2. Monitoramento em tempo real da CPU do processo de negócios
A cópia do código é a seguinte:
função getcpu
{
Cpuvalue = `ps -p $ 1 -o pcpu | grep -v cpu | awk '{print $ 1}' | awk - F. '{print $ 1}' `
eco $ cpuvalue
}
A função a seguir é obter a utilização da CPU desse processo através da função acima GETCPU e, em seguida, usar a instrução condicional para determinar se a utilização da CPU excede o limite. Se exceder 80% (poderá ser ajustado de acordo com a situação real), um alarme será emitido, caso contrário, as informações normais serão emitidas.
Listagem 3. Determine se a utilização da CPU excede o limite
A cópia do código é a seguinte:
função checkcpu
{
PID = $ 1
CPU = `getCPU $ pid`
Se [$ CPU -GT 80]
Então
{
eco “O uso da CPU é maior que 80%”
}
outro
{
eco “o uso da CPU é normal”
}
fi
}
Demonstração de amostra:
1) Programa de origem (assumindo que o ID do processo do CFTESTAPP foi consultado acima é 11426)
A cópia do código é a seguinte:
Checkcpu 11426
2) Resultados Saída
A cópia do código é a seguinte:
O uso da CPU é 75
O uso da CPU é normal
[dyu@xilinuxbldsrv shell] $
3) Análise de resultados
Como pode ser visto na saída acima: o uso atual da CPU do programa CFTESTAPP é de 75%, o que é normal e não há limite de alarme de mais de 80%.
Detectar o uso da memória do processo
Ao manter os serviços de aplicativos, é frequentemente encontrado que o processo trava devido ao uso excessivo da memória, resultando em interrupção de negócios (por exemplo, o espaço máximo de memória que um programa de 32 bits pode abordar é 4G, se exceder a memória, a memória falhará e a memória física também é limitada). O uso excessivo da memória pode ser devido ao vazamento de memória, acumulação de mensagens, etc. O uso da memória do processo de negócios pode ser monitorado em tempo hábil através de scripts, e os alarmes podem ser enviados em tempo hábil quando o uso da memória é anormal (como através do SMS) para facilitar o pessoal de manutenção para lidar com isso de maneira oportuna. A função a seguir pode obter o uso da memória do processo do ID do processo especificado. Ele possui um parâmetro como ID do processo, que primeiro usa o PS para encontrar informações do processo, filtra as linhas do VSZ através do Grep -V e depois leva o uso da memória em megabytes dividindo 1000.
Listagem 4. Monitoramento do uso da memória do processo de negócios
A cópia do código é a seguinte:
função getMem
{
Memusage = `ps -o vsz -p $ 1 | grep -v vsz`
((Memusage /= 1000))
eco $ MEMUSAGEM
}
A função a seguir é obter o uso de memória desse processo através da função acima getMem e, em seguida, usar a instrução condicional para determinar se o uso da memória excede o limite. Se exceder 1,6g (poderá ser ajustado de acordo com a situação real), um alarme será emitido, caso contrário, as informações normais serão emitidas.
Listagem 5. Determine se o uso da memória excede o limite
A cópia do código é a seguinte:
Mem = `getMem $ pid`
Se [$ MEM -GT 1600]
Então
{
eco “o uso da memória é maior que 1,6g”
}
outro
{
eco “o uso da memória é normal”
}
fi
Demonstração de amostra:
1) Programa de origem (assumindo que o ID do processo do CFTESTAPP foi consultado acima é 11426)
A cópia do código é a seguinte:
Mem = `getMem 11426`
eco "O uso da memória é $ Mem M"
Se [$ MEM -GT 1600]
Então
{
eco "o uso da memória é maior que 1,6g"
}
outro
{
eco "o uso da memória é normal"
}
fi
2) Resultados Saída
A cópia do código é a seguinte:
O uso da memória é de 248 m
O uso da memória é normal
[dyu@xilinuxbldsrv shell] $
3) Análise de resultados
A partir da saída acima, podemos ver que o uso atual da memória do programa CFTESTAPP é de 248m, o que é normal e não há limite de alarme superior a 1,6g.
Detectar o processo de lidar com o uso
Ao manter os serviços de aplicativos, as interrupções de negócios são frequentemente encontradas devido ao uso excessivo de manipulação. Cada plataforma usa alças de processo com uso limitado. Por exemplo, na plataforma Linux, podemos usar o comando ULIMIT N (Abra os arquivos (-n) 1024) ou visualizar o conteúdo de /etc/security/limits.conf para obter restrições de manipulação do processo. Se a alça for usada muito alta, o vazamento da alça pode ser devido a carga excessiva, vazamento da alça, etc. O uso do processo de negócios é monitorado em tempo hábil através de scripts, e os alarmes podem ser enviados em tempo hábil em caso de anormalidades (como através do SMS) para facilitar a manutenção de manutenção para lidar com ela de uma maneira oportuna. A função a seguir pode obter o processo de lidar com o uso do ID do processo especificado. Possui um parâmetro como ID do processo. Primeiro, ele usa o LS para produzir as informações do processo do processo e, em seguida, conta o número de alças de saída através do WC -L.
A cópia do código é a seguinte:
função getdes
{
DES = `ls/proc/$ 1/fd | wc -l`
eco $ des
}
A função a seguir é obter o uso do manipulação desse processo através da função acima getDes e, em seguida, usar a instrução condicional para determinar se o uso do manipulação excede o limite. Se exceder 900 (poderá ser ajustado de acordo com a situação real), um alarme será emitido, caso contrário, as informações normais serão emitidas.
A cópia do código é a seguinte:
DES = `getdes $ pid`
Se [$ des -gt 900]
Então
{
eco “O número de DES é maior que 900”
}
outro
{
eco “o número de DES é normal”
}
fi
Demonstração de amostra:
1) Programa de origem (assumindo que o ID do processo do cftestapp é encontrado acima é 11426)
A cópia do código é a seguinte:
DES = `getdes 11426`
eco "O número de des é $ des"
Se [$ des -gt 900]
Então
{
eco "O número de DES é maior que 900"
}
outro
{
eco "o número de DES é normal"
}
fi
2) Resultados Saída
A cópia do código é a seguinte:
O número de DES é 528
O número de DES é normal
[dyu@xilinuxbldsrv shell] $
3) Análise de resultados
A partir da saída acima, podemos ver que o identificador atual do programa CFTESTAPP é 528, o que é normal e não há limite de alarme de mais de 900.
4) Introdução ao comando
WC: Estatísticas O número de bytes, palavras e linhas no arquivo especificado e exibe os resultados estatísticos para saída. Parâmetros: -l Conta o número de linhas. -C Conta o número de bytes. -w contagem de palavras contagem de palavras.
Verifique se uma porta TCP ou UDP está ouvindo
A detecção de portas é frequentemente encontrada na detecção de recursos do sistema, especialmente na comunicação de rede, a detecção de status da porta geralmente é muito importante. Às vezes, os processos, a CPU, a memória etc. podem estar no estado normal, mas a porta está em estado anormal e os negócios não estão em execução normalmente. A função a seguir pode determinar se a porta especificada está ouvindo. Possui um parâmetro que é a porta a ser detectada. Primeiro, ele usa o NetStat para produzir as informações de ocupação da porta e depois filtra o número de saída de portas TCP através de Grep, Awk, WC. A segunda declaração é produzir o número de monitores das portas UDP. Se as portas TCP e UDP forem 0, retorne 0, caso contrário, retorne 1.
Listagem 6. Detecção de porta
A cópia do código é a seguinte:
função escuta
{
TcPlisteningNum = `netStat -an | grep ": $ 1" | /n
awk '$ 1 == "tcp" && $ nf == "escute" {print $ 0}' | wc -l`
UdplisteningNum = `netStat -an | grep": $ 1 " /n
| AWK '$ 1 == "UDP" && $ nf == "0.0.0.0:*" {print $ 0}' | wc -l`
((Escutanum = tcPlisteningNum + udplisteningNum))
Se [$ auditionnum == 0]
Então
{
eco "0"
}
outro
{
eco "1"
}
fi
}
Demonstração de amostra:
1) Programa de origem (por exemplo, consulta se o status da porta 8080 está ouvindo)
A cópia do código é a seguinte:
islisten = `ouvindo 8080`
Se [$ islisten -eq 1]
Então
{
eco "a porta está ouvindo"
}
outro
{
eco "a porta não está ouvindo"
}
fi
2) Resultados Saída
A cópia do código é a seguinte:
A porta está ouvindo
[dyu@xilinuxbldsrv shell] $
3) Análise de resultados
A partir da saída acima, pode -se observar que a porta 8080 deste servidor Linux está no estado de escuta.
4) Introdução ao comando
NETSTAT: usado para exibir dados estatísticos relacionados a protocolos IP, TCP, UDP e ICMP e geralmente é usado para verificar o status de conexão de rede de cada porta da máquina. Parâmetros: -a Exibe soquetes em todas as conexões. -n Use o endereço IP diretamente, não através do servidor de nomes de domínio.
A função a seguir também é detectar se uma porta TCP ou UDP está em um estado normal.
A cópia do código é a seguinte:
TCP: netStat -an | egrep $ 1 | Awk '$ 6 == "Ouça" && $ 1 == "TCP" {print $ 0}'
UDP: netStat -an | egrep $ 1 | Awk '$ 1 == "udp" && $ 5 == "0,0.0.0:*" {print $ 0}'
Introdução ao comando
EGREP: Encontre a sequência especificada no arquivo. O efeito de execução do EGREP é como Grep -e. A sintaxe e os parâmetros utilizados podem ser referidos à instrução Grep. A diferença do Grep é o método de interpretar cordas. O EGREP é interpretado usando sintaxe de expressão regular estendida, enquanto o Grep usa sintaxe básica de expressão regular. Expressões regulares estendidas têm especificações de expressão mais completas do que expressões regulares básicas.
Verifique o número de processos em execução
Às vezes, podemos precisar obter o número de iniciantes de um processo no servidor. A função a seguir é detectar o número de processos em execução, como o nome do processo é Cftestapp.
A cópia do código é a seguinte:
Runnum = `ps -ef | grep -v vi | CAIL GREP -V | grep "[ /] cftestapp" | grep -v grep | wc -l
Detectar o sistema de CPU do sistema
Ao manter o servidor, às vezes a interrupção dos negócios é encontrada devido à carga excessiva do sistema (utilização). Pode ser possível executar vários processos no servidor. É normal visualizar a CPU de um único processo, mas a carga da CPU de todo o sistema pode ser anormal. A carga da CPU do sistema é monitorada em tempo hábil através de scripts, e os alarmes podem ser enviados em tempo hábil em caso de anormalidades, o que facilita o pessoal de manutenção para lidar com isso em tempo hábil e evitar acidentes. A função a seguir pode detectar o uso da CPU do sistema. Use o VMSTAT para obter o valor ocioso da CPU do sistema 5 vezes, aceitar o valor médio e, em seguida, obtenha o valor real da ocupação da CPU atual, obtendo a diferença de 100.
A cópia do código é a seguinte:
função getSysCPU
{
Cpuidle = `vmstat 1 5 | sed -n '3, $ p' /n
| awk '{x = x + $ 15} end {print x/5}' | awk -f. '{print $ 1}'
Cpunum = `echo" 100- $ cpuidle "| bc`
eco $ cpunum
}
Demonstração de amostra:
1) Programa de origem
A cópia do código é a seguinte:
CPU = `getSycpu`
eco "A CPU do sistema é $ CPU"
Se [$ CPU -GT 90]
Então
{
eco "O uso da CPU do sistema é maior que 90%"
}
outro
{
eco "o uso da CPU do sistema é normal"
}
fi
2) Resultados Saída
A cópia do código é a seguinte:
A CPU do sistema é 87
O uso da CPU do sistema é normal
[dyu@xilinuxbldsrv shell] $
3) Análise de resultados
Na saída acima, podemos ver que a taxa de utilização da CPU atual do sistema de servidor Linux é de 87%, o que é normal e não há limite de alarme de mais de 90%.
4) Introdução ao comando
VMSTAT: abreviação de estatísticas virtuais de meomoria, que podem monitorar a memória virtual, processos e atividades da CPU do sistema operacional.
Parâmetros: -n significa que quando as informações do cabeçalho em saída são exibidas apenas uma vez durante a saída cíclica periódica.
Detectar o espaço do disco do sistema
A detecção de espaço em disco do sistema é uma parte importante da detecção de recursos do sistema. Durante a manutenção do sistema, geralmente precisamos verificar o uso do espaço do disco do servidor. Como algumas empresas precisam escrever folhas de chamadas, logs ou arquivos temporários a qualquer momento, se o espaço do disco estiver esgotado, isso também pode causar interrupção de negócios. A função a seguir pode detectar o uso do espaço em disco de um diretório no espaço atual do disco do sistema. O parâmetro de entrada é o nome do diretório que precisa ser detectado, use o DF para produzir as informações de uso do espaço em disco do sistema e, em seguida, obtenha a porcentagem de uso do espaço em disco de um diretório através da filtragem Grep e Awk.
A cópia do código é a seguinte:
função getDiskspc
{
Se [$# -ne 1]
Então
retornar 1
fi
Pasta = "$ 1 $"
Diskspace = `df -k | Grep $ pasta | Awk '{print $ 5}' | Awk -f% '{print $ 1}'
Echo $ Diskspace
}
Demonstração de amostra:
1) Programa de origem (o diretório de detecção é /bota)
A cópia do código é a seguinte:
Pasta = "/bota"
Diskspace = `getDiskspc $ pasta`
eco "O espaço do disco do sistema $ é $ DISKSPACE%"
Se [$ DISKSPACE -GT 90]
Então
{
eco "O uso do disco do sistema (Pasta $) é maior que 90%"
}
outro
{
eco "O uso do disco do sistema ($ pasta) é normal"
}
fi
2) Resultados Saída
A cópia do código é a seguinte:
O espaço do disco do sistema /inicialização é de 14%
O uso do disco do sistema (/bota) é normal
[dyu@xilinuxbldsrv shell] $
3) Análise de resultados
Como pode ser visto na saída acima: atualmente, o espaço em disco do diretório /inicialização deste sistema de servidor Linux foi usado em 14%, o que é normal e não há limite de alarme de mais do que o uso de 90%.
4) Introdução ao comando
DF: Verifique o uso do espaço do disco do sistema de arquivos. Este comando pode ser usado para obter informações como quanto espaço o disco rígido ocupou e quanto espaço resta. Parâmetros: -k é exibido em k bytes.
Resumir
Na plataforma Linux, o Monitoramento de Scripts do Shell é um método muito simples, conveniente e eficaz para monitorar servidores e processos, o que é muito útil para o desenvolvimento de desenvolvimento e manutenção de processos. Ele pode não apenas monitorar as informações acima e enviar alarmes, mas também monitorar logs de processos e outras informações. Espero que este artigo seja útil para todos.