Encontrando Alternativas para chats de voz

Maioria dos programas dedicados a gamers não tem suporte para Linux. Uma das saídas é usar o Wine para conseguir rodar, com a ajuda do Play On Linux o trabalho fica fácil quando disponível, mas sem ele se torna uma dor de cabeça  grande tentar rodar um programa do Windows no Linux. Um desafio recente foi rodar um chat de voz que era comum entre amigos, porem nenhuma das alternativas para instalar ele haviam sido efetivas. Quando não se consegue usar programa desejado de jeito nenhum, opte por um programa que seja semelhante e que quebre as barreiras sociais existentes entre os sistemas operacionais. Uma dessas opções é Mumble um programa leve que a não atrapalha na performance e que possui versões para Windows, Linux e Mac

Mumble não é um programa belo, é simples e direto. Ganha pontos na leveza e versatilidade.

mumble3

A instalação no Linux é bem simples, com 3 linhas de comando ele já está pronto para ser usado.

Ubuntu

sudo add-apt-repository ppa:mumble/release
sudo apt-get update
sudo apt-get install mumble


Conta com um bom sistema para configurar a entrada e saída de som ao iniciar o programa pela primeira vez.mumble2.

Não possui a necessidade contas para criação de salas ou entrar nos servidores. Basta localizar o servidor mais próximo que possua uma boa latência, escolher um nick, conectar e escolher uma sala para ficar com os amigos. mumble4

 

Lado negativo é que as salas são publicas e falta privacidade. No Linux pode gerar uma ligeira desconfiguração no som das demais atividades feitas no computador, durante o uso do Mumble.

Pequenos problemas a parte ele é super rápido de instalar e em caso de estar usando um computador diferente do habitual você seus amigos podem instalar rapidinho enquanto carrega a partida do seu MOBA preferido(Como League of Legends).

Comunicação é a chave para vitoria, bom jogo.

Como criar e manipular contêineres no Docker

Há várias formas de iniciar o uso do Docker e fazer uso dos containers. Neste texto, vou me concentrar nos comandos de execução — a começar por alguns comandos de verificação do estado da sua instalação.
Para saber se o Docker foi instalado corretamente, use o parâmetro ‘info’, na linha de comando:

docker info

O comando deve retornar algo semelhante ao que se vê abaixo:

Containers: 48
Images: 18
Storage Driver: aufs
 Root Dir: /var/lib/docker/aufs
 Dirs: 114
Execution Driver: native-0.2
Kernel Version: 3.13.0-63-generic
WARNING: No swap limit support

A saída do comando vai depender da configuração atual do seu sistema e do Docker.

O Docker trabalha sob a perspectiva cliente/servidor.
O mesmo binário Docker é usado tanto pelo servidor quanto pelos comandos do cliente.
Desta forma, quando executamos os comandos do lado do cliente, estes são repassados ao daemon Docker, em execução no seu sistema.

Para rodar um contêiner, use o comando ‘run’ (do próprio Docker).
Note que, nos exemplos deste artigo, o docker é usado pelo usuário normal — sem privilégios administrativos.
Na configuração padrão do aplicativo, é necessário rodá-lo precedido do sudo ou como root.
Leia mais sobre como configurar o docker para rodar com os privilégios de usuário comum, aqui.
O comando que segue, vai colocar a imagem do Ubuntu (ou a tag mais atual dele) para rodar como um contêiner, com uma shell bash dentro:

docker run -i -t ubuntu /bin/bash

Veja o que mais foi feito acima:

  • -i pede para que a entrada ou input permaneça aberta, para receber instruções
  • -t pede ao contêiner para atribuir-lhe um terminal
  • /bin/bash é a opção de programa terminal escolhida

Se vocẽ abrir uma nova janela do console (Ctrl + Alt + T, no Ubuntu), agora, vai poder verificar que o contêiner está rodando. Use o comando ‘ps’ do Docker, para isto:

docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
bdaaca495be7        ubuntu:latest       /bin/bash           10 seconds ago      Up 10 seconds                           jolly_meitner

O Docker é um excelente construtor de blocos para sistemas distribuídos e automatizados — o que inclui aplicações web de larga escala, clusters de bancos de dados, sistemas de distribuição/desenvolvimento continuado, PaaS privado, arquiteturas orientadas a serviço etc.
(Manual do Docker)

Os contêineres podem ser identificados e chamados pelos seus IDs. Tendo vários no seu sistema, cada contêiner terá sua própria identificação.
Se você acrescentar a opção ‘-a’, o Docker irá mostrar mais — o que inclui os contêineres que já estão parados no sistema.
dokcer-ps--a
Note as colunas das extremidades: à esquerda fica a ID de cada contêiner. À direita, o seu nome.
Você pode se referir a um contêiner, pela sua ID ou, se preferir, pelo seu nome.
O Docker “batiza” todos os novos contêineres criados sem nome. Ele cria/escolhe nomes aleatórios — jolly_meitner, goofy_hopper, stoic_torvalds etc. (Veja a figura, acima).

Como nomear contêineres Docker

Como já mencionei, é possível (e opcional) dar um nome a cada novo contêiner criado no Docker.
Caso o usuário não o faça, o Docker cria um nome aleatório e o atribui ao novo contêiner, no momento de sua criação.
Mas você pode (e deve) dar nomes que tenham mais significado para você.
Use o parâmetro ‘–name’ para escolher e atribuir um nome ao seu contêiner:

docker run --name primeiro_conteiner -i -t ubuntu /bin/bash

De dentro de um contêiner, use o comando ‘exit’ para terminá-lo e sair.

Opções para parar e iniciar um contêiner Docker

Você pode iniciar e parar um contêiner, com o uso dos comandos ‘start’ e ‘stop’, seguido da ID ou do nome do contêiner que você deseja atingir:

docker start 697f662350ab
697f662350ab
docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
697f662350ab        ubuntu:latest       /bin/bash           7 minutes ago       Up 6 seconds                            primeiro_conteiner   
bdaaca495be7        ubuntu:latest       /bin/bash           About an hour ago   Up About an hour                        jolly_meitner        
docker stop primeiro_conteiner
primeiro_conteiner
docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
bdaaca495be7        ubuntu:latest       /bin/bash           About an hour ago   Up About an hour                        jolly_meitner

docker-start-stop
Como você pode ver, nos exemplos acima (tanto no texto quanto na imagem), é possível se referir tanto ao ID quanto ao nome de um contêiner.
Ao aplicar os exemplos, você deve ter percebido que, embora o contêiner volte a rodar, você não está “dentro dele”.
Para poder assumir o controle da linha de comando (shell) dentro de um contêiner, use o comando ‘attach’ — seguido do seu ID ou do seu nome:

docker attach bdaaca495be7

Como rodar um contêiner em modo daemon

Além de usar estes contêineres interativos, que vimos até agora, podemos rodá-los nos bastidores do sistema ou daemonized.
Este modo é muito útil para executar tarefas (aplicações ou serviços) de longa duração em um contêiner.
Na verdade esta é a maneira mais comum de se executar Docker containers.
Veja um exemplo:

docker run --name primeiro_daemon -d ubuntu /bin/sh -c "while true; do echo ola mundo; sleep 1; done"
65f05aeced672283ba639aa240268d23fdaa7713ca0beb66da3f39155224502c

Aqui, usamos o comando ‘docker run’, em conjunto com o parâmetro ‘-d’ para enviar o contêiner pros bastidores ou background.
Dentro dele, escrevemos um pequeno script em loop, como comando.
O script envia a frase “ola mundo” uma vez a cada segundo, até ser interrompido — parando o contêiner ou o processo.
Com esta combinação de opções e parâmetros, é possível ver que o Docker não te coloca na shell de comandos. Ele apenas retorna a ID do contêiner o prompt linha de comando do seu terminal — enquanto o script continua a ser executado dentro do contêiner.
Como você já sabe, é possível acompanhar a execução dele, através do comando docker ps:

docker ps
CONTAINER ID        IMAGE               COMMAND                CREATED             STATUS              PORTS               NAMES
65f05aeced67        debian:latest       /bin/sh -c 'while tr   29 minutes ago      Up 29 minutes                           primeiro_daemon     
bdaaca495be7        ubuntu:latest       /bin/bash              2 hours ago         Up 43 minutes                           jolly_meitner

Como ver o que acontece dentro de um contêiner

É possível, a qualquer momento, obter informações sobre processos que estejam em execução dentro de contêineres.
Neste momento, há um com um laço while em execução.
Você pode usar o comando ‘logs’ do Docker para obter informações sobre o andamento da execução dos processos:

docker logs primeiro_daemon
ola mundo
ola mundo
ola mundo

...

O comando ‘logs’ vai mostrar o resultado do script em execução no contêiner.
Se você deseja monitorar os resultados de alguma tarefa, acrescente a opção ‘-f’ — e observe os resultados como se estivesse executando o tails:

docker logs -f primeiro_daemon

Acrescente a opção ‘-t’ para exibir o timestamp ao lado de cada resultado:

docker logs -tf primeiro_daemon
[Sep 14 17:40:59.675] ola mundo
[Sep 14 17:41:00.676] ola mundo
[Sep 14 17:41:01.677] ola mundo
[Sep 14 17:41:02.678] ola mundo
[Sep 14 17:41:03.680] ola mundo
[Sep 14 17:41:04.681] ola mundo
[Sep 14 17:41:05.683] ola mundo
[Sep 14 17:41:06.684] ola mundo
[Sep 14 17:41:07.686] ola mundo
[Sep 14 17:41:08.688] ola mundo

Para concluir o monitoramento, pressione Ctrl + C.
Uma outra forma de observar o trabalho dentro do contêiner é rodando o comando ‘top’ com o Docker:

docker top primeiro_daemon
[/false]

UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                13434               2306                0                   14:37               ?                   00:00:00            /bin/sh -c while true; do echo ola mundo; sleep 1; done
root                16200               13434               0                   15:13               ?                   00:00:00            sleep 1

Também é possível ver estatísticas de funcionamento dos processos, através do comando ‘stats’:

sudo docker stats primeiro_daemon
CONTAINER           CPU %               MEM USAGE/LIMIT     MEM %               NET I/O
primeiro_daemon     0.12%               557.1 kB/8.059 GB   0.01%               10.47 kB/648 B

Para sair do painel de estatísticas, use a combinação Ctrl + C.

Como iniciar outro processo dentro de um contêiner existente

Um contêiner preexistente e com processos em andamento, pode aceitar novas tarefas e/ou novos processos, sem problemas — esta também é uma situação muito comum.
O comando ‘exec’ do Docker é que permite acrescentar tarefas aos contêineres.
Estas tarefas podem ser de 2 tipos: de background ou interativas.
As primeiras são inseridas para execução no contêiner e não tem interação depois disto.
As tarefas interativas são interessantes, pois permitem abrir uma shell dentro do contêiner.
Veja, no exemplo, como executar um comando em segundo plano dentro de um contêiner:

docker exec -d primeiro_daemon touch /etc/new_config_file

Aqui, o ‘-d’ sinaliza um processo rodando em segundo plano.
Em seguida, especificamos o nome do contêiner que queremos atingir e o comando que irá ser executado dentro dele.
Neste caso, o comando touch cria um arquivo vazio ‘new_config_file’ dentro do diretório ‘/etc’ dentro do contêiner ‘primeiro_daemon’.
Desta forma é que podemos usar o comando ‘exec’ do Docker para rodar comandos de manutenção, aplicativos de monitoramento, gerenciar tarefas etc. tudo dentro dos contêineres.
Com este método, é possível alterar a execução de um script on the fly.
Se você deseja obter acesso a uma shell dentro do contêiner, use as opções ‘-t’ e ‘-i’ (que já foram vistas anteriormente).
Com estas opções, é possível criar um terminal TTY e capturar o STDIN (standard input) dos processos em execução.
Além disto, é preciso indicar qual o contêiner e qual programa de shell a ser usado. Veja o exemplo:

docker exec -t -i primeiro_daemon /bin/bash

root@a3f74bdffacc:/# echo "Olha mae! Estou dentro do container!"

Olha mae! Estou dentro do container!

root@a3f74bdffacc:/# exit

Como você pode ver, o comando acima, criou uma nova sessão bash — dentro da qual é possível dar comandos dentro do contêiner.
No nosso exemplo, não esqueça, existe um processo rodando em background, ainda, dentro do ‘primeiro_daemon’.

Como reiniciar automaticamente um contêiner

Se um contêiner parar ou for finalizado em consequência de um erro, é possível configurar o Docker para pô-lo pra rodar de novo automaticamente — para o caso de você não “estar por perto”, isto pode ser útil.
Podemos sinalizar com ‘–restart’, quando queremos que haja um reinício e até quantas vezes tentar.
A flag ‘–restart’ aceita valores, como ‘always’ (sempre) e ‘on-failure’ (em caso de falhas).
Veja um exemplo:

docker run --restart=on-failure:3 --name segundo_daemon -d ubuntu /bin/sh -c "while true; do echo ola mundo; sleep 1; done"
4f505f038e885ef24f5b63474f28778f75d22098a4597d19dd92ff9cf1bb20d4

Neste exemplo, portanto, a configuração --restart=on-failure:3 pede para que ele tente retomar suas atividades, em caso de falha, (failure) até 3 vezes.

Como obter mais informações sobre um contêiner

O comando ‘inspect’ pode oferecer mais dados sobre um determinado contêiner.
Experimente:

docker inspect segundo_daemon

A saída deste comando pode ser muito extensa.
Para filtrar apenas a informação desejada, use o comando grep ou a opção ‘–format’ do docker:

docker inspect segundo_daemon | grep -A5 -i "state"
    "State": {
        "Running": true,
        "Paused": false,
        "Restarting": false,
        "OOMKilled": false,
        "Dead": false,

A opção ‘-A5’, do comando grep, diz para mostrar mais 5 linhas além daquela que contém a string ‘state’.
O que se vê é que o processo está rodando, não está pausado, não foi reiniciado, não foi alvo de um kill, não está morto…
Com a opção ‘–format’, é possível obter uma resposta mais objetiva para “o contêiner está em execução?”:

docker inspect --format='{{ .State.Running }}' segundo_daemon

true

Se quiser obter informações sobre as configurações de rede, use o template .NetworkSettings.IPAddress. No exemplo abaixo, mostro como obter informações de 2 contêineres (ou mais. Basta enfileirar os nomes):

docker inspect --format='{{ .NetworkSettings.IPAddress }}' segundo_daemon primeiro_daemon
172.17.0.2
172.17.0.3

Experimente explorar o diretório /var/lib/docker, onde se encontram imagens e configurações variadas de contêineres.
Já, os seus contêineres (que você criou) podem ser encontrados em /var/lib/docker/containers.

Como remover um contêiner

Ao terminar de usar um contêiner, é possível usar o Docker command ‘rm’ (remove).
É o mesmo comando que usamos para remover arquivos no UNIX ou no GNU/Linux.
Nas versões atuais do Docker, é possível remover um contêiner, ainda em execução, com o uso da opção ‘-f’ (force):

docker rm -f primeiro_daemon segundo_daemon
primeiro_daemon
segundo_daemon

Se quiser conferir a remoção, use o comando ‘ps’:

docker ps -a

No meu caso, não há mais nenhum contêiner rodando:

CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES

Este artigo abordou o uso básico do Docker, com comandos para iniciar instâncias do aplicativo e como manipular processos internamente. Vimos, ainda, como obter informações sobre os recipientes e, finalmente, como removê-los e onde encontrar mais imagens e configurações prontas, que podem ajudar a aprender mais sobre o assunto.
Há outros artigos sobre o uso do Docker neste site. Para encontrá-los, experimente usar a caixa de pesquisa.

Referências:
Google Books.
Slashroot.

Como limitar o uso de recursos dos usuários em sistemas UNIX e Linux com o comando ulimit

A limitação de recursos do sistema é a prática de regular até onde usuários, aplicativos e processos podem ir, com o objetivo de manter um equilíbrio entre a completa experiência de usuário e a segurança do sistema.
É bom frisar que, ainda que ajustados em função dos usuários, internamente, sua aplicação se refere aos processos.
Esta abordagem permite que usuários com limitações de recursos, possam rodar softwares que dependam de uma grande quantidade de processos abertos — ou seja, mesmo que um usuário esteja limitado a rodar no máximo 10 processos, ele pode fazer uso de aplicações gráficas (GNOME, KDE, Unity etc) que disparam, potencialmente, outras várias dezenas de processos.
Nos sistemas operacionais UNIX e GNU/Linux o comando ulimit é o que controla os limites dos recursos de sistema — tais como tamanho dos dados processos, quantidade de memória virtual que podem usar, quantidade máxima de arquivos que podem ser abertos etc.

Há diferenças entre um sistema e outro. O Solaris dá acesso ilimitado aos recursos ao root. No AIX, da IBM, há algumas limitações impostas ao superusuário.

Ao configurar os limites de recursos para um processo é importante saber que os limites que se aplicam são aqueles que afetam os processos pai e não os limites para o usuário que o está executando.
Por exemplo, o IBM Directory server roda sob uma conta de usuário ldap, criada no momento da instalação. Embora este serviço seja normalmente iniciado quando logado como root.
Se iniciado sob privilégios administrativos (root), quaisquer limites para o usuário ldap não afetam os processos pertencentes ao IBM Directory server. Para isto, o serviço precisa ser iniciado a partir da conta do usuário ldap.

Como obter informações sobre os limites de recursos de cada usuário

O comando ulimit pode configurar os recursos disponíveis “por usuário”, de maneira flexível (soft) ou rígida (hard).
Para ver todos os ajustes rígidos de recursos relativos ao usuário atual, use-o assim:

ulimit -Ha
core file size          (blocks, -c) unlimited
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 61250
max locked memory       (kbytes, -l) 64
max memory size         (kbytes, -m) unlimited
open files                      (-n) 4096
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) unlimited
cpu time               (seconds, -t) unlimited
max user processes              (-u) 61250
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

Para ver os ajustes flexíveis de recursos relativos ao usuário atual:

ulimit -Sa

As letras, entre parênteses, indicam a opção que pode ser dada ao ulimit para obter ou alterar aquela informação específica.

core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 61250
max locked memory       (kbytes, -l) 64
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 61250
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

Para ajudar a memorizar:

  • -H, de hard, se refere às opções rígidas.
  • -S, de soft, se refere às opções flexíveis.

Para exemplificar, se você quiser saber apenas qual a quantidade máxima de arquivos que podem ficar abertos, use ulimit -n.
O comando ulimit -a é equivalente a ulimit -Sa.
Você pode combinar parâmetros, para obter informações customizadas:

ulimit -v -x -u
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited
max user processes              (-u) 61250

No Linux, os ajustes rígidos de recursos são feitos pelo root para cada usuário, através do comando chuser.
Já os ajustes flexíveis, podem ser feitos pelo usuário comum livremente. Ou seja, desde que você não ultrapasse os valores estabelecidos pelos ajustes rígidos, pode alterá-los de acordo com suas necessidades.

Como alterar os limites flexíveis do usuário atual

Há momentos em que se deseja reduzir limites de recursos para a própria sessão — quando se deseja testar algum aplicativo, que se tenha dúvida quanto à qualidade de seu código.
Limitar fortemente a quantidade máxima de processos abertos simultaneamente por usuário (max user processes), pode prevenir que código malicioso de uma fork bomb, por exemplo, replique processos indefinidamente até derrubar o seu sistema.
Para aumentar a quantidade máxima de arquivos abertos open files, use o comando seguido da opção ‘-n’:

ulimit -n 2048

Seja parcimonioso(a) com a alteração dos limites flexíveis “para menos”. Valores muito baixos de alguns itens podem tornar o sistema impossível de operar.

Você vai encontrar valores diferentes de um UNIX para outro ou entre as várias distros GNU/Linux. Só para citar um exemplo desta variação, o Debian 8.1 32 bit (quando instalado via netinstall e sem ambiente gráfico), por padrão, usa o valor 841 no parâmetro max user processes. A versão 64 bit, usa o valor 7976.
Isto é normal.

Note, ainda que os valores alterados só valem para a sessão atual. Ao reiniciar o sistema, eles retornam à configuração anterior. Se você errar e ficar com um sistema inutilizável, basta reiniciar ou abrir um outro terminal.

Como configurar o arquivo /etc/security/limits

Para alterar e manter os valores, mesmo após reiniciar o sistema, faça as alterações dentro do arquivo /etc/security/limits.conf (nas distros derivadas do Debian).
O arquivo limits.conf deve ser configurado em 4 colunas:

Parâmetro Descrição
domain Esta coluna pode conter um nome de usuário (justincase, hkeitel) ou de um grupo (p/ex.: @grupo).
type Pode ser tanto soft, para flexível como hard, para rígido.
item Onde se incluem os parâmetros do sistema a configurar. Veja abaixo.
value Os valores podem ser dados em blocos (de 512 ou 1024 bytes, a depender do seu sistema operacional, do seu sistema de arquivos etc.

Os parâmetros de configuração, presentes no Ubuntu 14.04 e Debian 8.1, no arquivo /etc/security/limits.conf, são os seguintes:

  • core – limita o tamanho do arquivo de núcleo ou core file size ou core dump file size. Este arquivo é constituído por uma imagem da memória de um processo, quando ele é terminado abruptamente. Esta informação é geralmente usada por aplicativos depuradores (KB).
  • max data size. Limite do tamanho dos segmentos de dados dos processos (KB).
  • maximum filesize ou maior tamanho de arquivo permitido a um processo abrir (KB).
  • max locked-in-memory address space. O memlock é o tamanho máximo de memória física que pode ser retida por um processo.
    A função deste recurso é certificar que uma certa quantidade de informações esteja sempre armazenada na RAM e nunca movida para o swap — o que mantém a velocidade de acesso a esta informação (KB).
  • max number of open files ou maior quantidade de arquivos que podem ficar abertos simultaneamente (unidades).
  • rss – max resident set size. É a quantidade máxima de dados pertencentes a um processo, que pode ficar residente em memória RAM.
    Um dos motivos para limitar este item é impedir que uma única aplicação do seu sistema devore toda memória principal (RAM), o que forçaria todas as outras aplicações a usar o swap, que é extremamente lento. (KB)

Em computação, o RSS ou resident set size é a porção de memória ocupada por um processo, mantida na memória RAM.
O resto da memória ocupada vai estar no swap ou no sistema de arquivos — ou porque parte foi paginada ou por que partes do arquivo executável, ainda não foram carregadas.

  • stackmax stack size limita o tamanho do process stack ou pilha de processos em bytes. Ao atingir este limite, um sinal SIGSEV é gerado, obrigando o próximo processo a empregar uma nova pilha (KB).
  • cpumax CPU time representa o tempo dedicado pela CPU para processar instruções de um programa ou do sistema operacional (MIN).
  • nprocmax number of processes, delimita a quantidade máxima de processos para a sessão atual.
  • asaddress space limit, estabelece um teto para o tamanho máximo de um processo em memória virtual (KB).
  • maxloginsmax number of logins for this user ou maior número de autenticações no sistema permitido ao usuário atual.
  • maxsysloginsmax number of logins on the system ou maior número de autenticações no sistema permitido.
  • prioritythe priority to run user process with, designa a prioridade para rodar processos do usuário.
  • locksmax number of file locks the user can hold
  • sigpendingmax number of pending signals, especifica o limite de sinais que podem se enfileirar para atingir o ID do usuário, vindas de um determinado processo.
  • msgqueuemax memory used by POSIX message queues Estabelece a quantidade máxima (em bytes) de memória usada por filas de mensagens POSIX.
  • nicemax nice priority allowed to raise to values: [-20, 19]. Especifica um teto para aumentar o valor do nice, com o uso dos comandos setpriority e nice.
  • rtpriomax realtime priority, define um teto para a prioridade de tempo real para a sessão atual.
  • chrootchange root to directory, no Debian, permite informar um novo diretório para o superusuário.

Para que as alterações feitas ao arquivo /etc/security/limits.conf tenham efeito, é necessário reiniciar o sistema.
Para alterar individualmente os limites de usuários, use o comando chuser. Neste caso, basta fechar a sessão e se autenticar de novo para estar sob os efeitos dos novos ajustes.
Para finalizar o assunto, segue um exemplo de uso do comando para alterar o resident set size do usuário salsicha:

chuser rss=-1 salsicha

Referências:
Página do Manual do Linux: http://www.man-page.net/2/setrlimit.
The core dump file: http://man7.org/linux/man-pages/man5/core.5.html.

Como instalar e começar a usar o Docker no Ubuntu

O Docker pode ser instalado nos sistemas operacionais baseados no Debian GNU/Linux (o Ubuntu é um deles) via apt-get, como irei mostrar abaixo.
Nos meus exemplos, fiz uso do Ubuntu 14.04 LTS e do Debian 8.1 — ou seja, eles valem para todas as outras distros que sejam baseadas neles.
Nunca é demais lembrar que o Docker, no momento, só suporta as versões 64 bits destes sistemas operacionais.
Note que abordei a instalação das versões estáveis e instáveis (nightly build) do Docker em tópicos separados, neste post.

Como instalar o Docker no Ubuntu ou no Debian

Há basicamente 2 métodos de instalação (escolha o que for melhor pra você). No primeiro, vamos buscar o aplicativo dos repositórios oficiais da sua distro e no segundo vamos buscá-los do site.
A diferença é que no primeiro você estará optando por um versão não tão nova, porém mais estável. No segundo método, a opção é por uma versão mais atual.

sudo apt-get update
sudo apt-get install docker.io

Para saber a versão instalada, use a opção ‘–version’:

docker --version
Docker version 1.0.1, build 990021a

O outro método baixa e executa automaticamente o script de instalação direto do site do Docker: https://get.docker.com.
Esta solução necessita do aplicativo wget e pode ser usada para instalar uma versão mais atualizada do Docker.
Veja como:

sudo wget -qO- https://get.docker.com/ | sh

Aguarde um pouco e veja o script fazer o seu trabalho.
Ao final, verifique a versão instalada do aplicativo:

sudo docker --version
Docker version 1.8.1, build d12ea79

Para testar a instalação, execute o seguinte procedimento:

docker run hello-world

O resultado deve ser aproximadamente o que segue:

Unable to find image 'hello-world' locally
Pulling repository hello-world
af340544ed62: Download complete 
535020c3e8ad: Download complete 

Hello from Docker.
This message shows that your installation appears to be working correctly.

De acordo com a documentação oficial, a mensagem Hello from Docker (em destaque) indica que a instalação aparenta estar funcionando corretamente.
Para gerar esta mensagem, o cliente Docker passou pelas seguintes etapas:

  1. Contatou o daemon docker;
  2. O daemon trouxe a imagem “hello world” do Docker Hub;
  3. Em seguida, criou um novo contêiner a partir daquela imagem, que roda o executável que produz a mensagem, que foi destacada acima;
  4. O Docker daemon transmitiu a mensagem ao cliente, que a reenviou para o seu terminal.

Como instalar a versão experimental do Docker

Neste ponto estamos saindo da zona segura. Software em estágio experimental não deve ser executado em máquinas de produção.
O uso da versão em desenvolvimento de um aplicativo é interessante para quem deseja ter acesso aos últimos recursos que os programadores inseriram e não se importa de viver perigosamente.
Espere encontrar problemas ao usá-la.

Ao usar a versão nightly build de um software e relatar corretamente os problemas que você encontrou, você ajuda a equipe de desenvolvimento a melhorar o seu programa preferido.
Além disso, vocẽ fica fazendo parte do grupo de usuários que pode ter um primeiro contato com os novos recursos do software.

Se vocẽ quiser usar a última versão (nightly build) do Docker, no Ubuntu, rode o script a partir do site https://experimental.docker.com/.
Segue o procedimento:

wget -qO- https://experimental.docker.com/ | sh
docker --version
Docker version 1.9.0-dev, build 5dadfa8, experimental

A sua versão provavelmente será mais nova que a deste texto.
Se você quer usar a versão experimental e não quer desinstalar a versão estável, sugiro baixar diretamente o binário da nightly build version do Docker. O procedimento é o que segue:

wget https://experimental.docker.com/builds/Linux/x86_64/docker-latest
chmod +x docker-latest
./docker-latest version
/docker-latest version
Client:
 Version:      1.9.0-dev
 API version:  1.21
 Go version:   go1.4.2
 Git commit:   5dadfa8
 Built:        Wed Aug 26 17:33:57 UTC 2015
 OS/Arch:      linux/amd64
 Experimental: true

Configure o Docker para seu usuário

Como você já deve ter percebido, o Docker é executado através do sudo — com privilégios administrativos, portanto.
Para executá-lo sem isso, como usuário normal, faça o seguinte procedimento:

sudo usermod -aG docker justincase

No seu caso, substitua justincase pelo seu nome de usuário.