Como definir ulimits para um serviço iniciando na inicialização?

Eu preciso, para o mysql usar páginas grandes, definir um ulimit - eu fiz isso no limits.conf. No entanto, limits.conf (pam_limits.so), não é lido no init, apenas em shells "reais". Eu resolvi isso antes adicionando um "ulimit -l" à função de inicialização do initscript. Eu preciso de algum tipo de maneira repetível de fazer isso, agora que as caixas são gerenciadas com o chef e não queremos assumir um arquivo que seja de propriedade do RPM.

$ echo "* hard nofile 102400" >> /etc/security/limits.conf
$ echo "* soft nofile 102400" >> /etc/security/limits.conf
$ sysctl -w fs.file-max=102400
$ sysctl -p

As 4 etapas podem alterar os limites do seu sistema imediatamente e ainda podem funcionar após a reinicialização. Você pode alterar o número "102400" para o número máximo de arquivos abertos no seu sistema Linux, conforme desejar. e

$ sysctl -p

para carregar nas configurações sysctl do arquivo especificado ou /etc/sysctl.conf, se não houver nenhuma.

O /etc/sysctl.conf deve poder definir os itens de ulimits. Não pude testar isso muito bem, mas a pesquisa diz que você deve parar depois de definido no sysctl.conf.

Eu encontrei vários tópicos que mostram que ainda é um problema e minha equipe e eu discutimos algumas opções em torno disso e encontramos duas soluções possíveis.

Opção 1: A maioria dos scripts de rhel fonte /etc/init.d/functions, você pode alterar as configurações de ulimit lá

Opção 2: o init afirma que o / etc / initscript é originado todas as vezes antes que o init apareça, veja: http://linux.die.net/man/5/initscript . Curiosamente, eles dizem que é onde as pessoas podem definir ulimit =)

Snippet de receita independente com base neste URL:

http://pro.benjaminste.in/post/318453669/increase-the-number-of-file-descriptors-on-centos-

Snippet de receita:

ruby_block "edit /etc/sysctl.conf" do
  _file = "/etc/sysctl.conf"
  _comment = "# TWEAK BY CHEF"
  _content = "fs.file-max = 512000"
  block do
    file = Chef::Util::FileEdit.new(_file)
    file.insert_line_if_no_match(/#{Regexp.escape(_comment)}/, "#{_comment}\n#{_content}")
    file.write_file
  end
  not_if "cat #{_file} | grep '#{_comment}'"
  notifies :run, "execute[sysctl -p]", :immediately
end

execute "sysctl -p" do
  command "sysctl -p"
  returns 255 # which would normally signify error, but doesn't on sysctl on CentOS
  action :nothing
end

ruby_block "edit /etc/security/limits.conf" do
  _file = "/etc/security/limits.conf"
  _comment = "# TWEAK BY CHEF"
  _content = "* - nofile 65535"
  block do
    file = Chef::Util::FileEdit.new(_file)
    file.insert_line_if_no_match(/#{Regexp.escape(_comment)}/, "#{_comment}\n#{_content}")
    file.write_file
  end
  not_if "cat #{_file} | grep '#{_comment}'"
end

Minha solução foi simplesmente fazer isso em nossa receita de chef:

# Ensure ulimits are properly set for the initscript
bash "Set Ulimits" do
    user "root"
    code <<-EOH
    echo -e "n#Setting ulimits. Performed by chef recipe MYSQLULIMIT\nulimit -l" >> /etc/sysconfig/init
    EOH
    not_if "grep MYSQLULIMIT /etc/sysconfig/init"
end

Isso faz ulimit -lcom que o conjunto seja definido para todos os initscripts, o que pode ser indesejável em alguns ambientes, mas é bom para o meu.

Em um mundo perfeito, eu atualizaria o RPM para incluir /etc/sysconfig/mysqldae colocaria o mesmo comando ulimit -l.

Não tenho certeza de quão específica é a distribuição, mas acabei de incorporar um aumento no limite de segurança usando o /etc/security/limits.d/20-somefile.confUbuntu.

Em vez de precisar modificar um arquivo existente, tenho um modelo de ERB no meu livro de receitas, defino atributos padrão em um arquivo de atributos e não preciso me preocupar em usar blocos de rubi com material "insert_line_if_no_match" - isso parece um pouco mais complicado e a receita é um pouco mais legível assim:

execute "activate_sysctl" do
  user "root"
  command "sysctl -p /etc/sysctl.d/10-filemax.conf"
  action :nothing
end

template "/etc/sysctl.d/10-filemax.conf" do
  source "system/filemax.conf"
  action :create
  notifies :run, "execute[activate_sysctl]", :immediately
end

e então este é o meu arquivo de modelo:

fs.filemax = <%= node[:mycookbook][:system_fs_filemax] %>

de acordo com a página de manual, ulimit foi descontinuado. Você precisa usar o setrlimit. O problema é que é uma chamada do sistema em vez de um comando bash.

Eu tive esse problema com o supervisor e foi isso que descobri. Se o processo não tiver um arquivo de configuração que permita fazer uma chamada para a chamada de sistema setrlimit (). Defina-o com ulimit em seu script /etc/init.d bash. Esse é o script de serviço que inicia seu processo.

Se o processo tiver um arquivo de configuração, como o supervisor d, você poderá usá-lo para definir o número de arquivos e fazer com que o processo faça a chamada diretamente para setrlimits ().

Supervisor: http://supervisord.org/configuration.html#supervisord-section-settings

TomcaT: http://www.jayway.com/2012/02/11/how-to-really-fix-the-too-many-open-files-problem-for-tomcat-in-ubuntu/

A maneira RedHat, conforme descrito no artigo 253043 (assinatura necessária), é adicionar instruções ulimit apropriadas a /etc/sysconfig/<service name>. Por exemplo:

# echo "ulimit -SHn 10240   # nfile" >> /etc/sysconfig/myServiceName

(Use o arquivo existente para o seu serviço em vez de myServiceName.)

Para daemons que iniciam sem usar o script "sysconfig" do RedHat, é necessário incluir as linhas ulimit apropriadas no script de inicialização do daemon.

Tente configurá-lo no arquivo /etc/sysctl.conf

Na verdade, eu escrevi um livro de receitas de chef particular que é usado para definir ulimit para nós e funciona muito bem. Para o ubuntu, descobrimos o seguinte truque, se você quiser uma configuração ulimit global:

Adicione o seguinte à sua sessão comum:

session required        pam_limits.so

e no limit.conf, você deve ter o seguinte:

* soft  nofile  64000
* hard  nofile  65000

root  soft  nofile  64000
root  hard  nofile  65000

A parte raiz é importante, pois parece que algum script init não funcionará corretamente. Portanto, temos um livro de receitas do chef que define o seguinte e funciona muito bem.

Outra opção que costumávamos usar para o Tomcat era implantar o Tomcat e substituir o script init por um costume para o qual definiríamos o ulimit e reiniciaríamos o tomcat. Isso funciona muito bem, mas é um pouco mais hacky do que o primeiro.

Espero que isso ajude, e talvez um dia eu possa abrir código-fonte do livro de receitas que temos internamente, já que é bastante simples, mas pode ser útil para outras pessoas como você.