Elixir version manager

É certo que instalar o Elixir é algo relativamente simples, mas, assim como no Ruby, é normal que queiramos instalar e desinstalar versões do Elixir com facilidade, ou mesmo querer ter mais de uma versão instalada para testes diversos, como por exemplo, usar a nova versão 1.7 que acaba de sair. Se é isso que você precisa, o Kiex pode te salvar!

Acho que um dos primeiros passos que fiz quando comecei a estudar Elixir foi verificar se ele tinha algo parecido com o RVM/Rbenv do Ruby, que me deixasse livre pra ter a versão desejada do Elixir a qualquer instante.

Após uma pequena procura achei o Kiexque cumpre isso de forma simples como de costume para usuários do RVM/Rbenv, no entanto, sabemos que o Elixir precisa ter o Erlang instalado por tabela para que ela funcione, então, caso você não tenha instalado ainda o Erlang em sua máquina, apenas o Kiex não funcionará.

Para nossa sorte, existe um Erlang Version Manager chamado Kerl que pode fazer essa dobradinha em conjunto com o Kiex para que também seja possível gerenciar as versões desejadas do Erlang.

É claro que existem outros gerenciadores de versão para ambas as linguagens, inclusive um genérico chamado ASDF que permite instalar e gerir várias linguagens de programação ao mesmo tempo, no entanto vi algumas pessoas precisando fazer algumas configurações extras para ele funcionar corretamente, então, por enquanto estou preferindo usar versionadores separados, além também de terem uma sintax de uso muito parecida com o RVM, o que já facilita o uso pra mim.

Uma coisa muito importante é saber que existe uma compatibilidade que deve ser respeitada entre as versões do Erlang e do Elixir. Então devemos verificar essa tabela (https://hexdocs.pm/elixir/compatibility-and-deprecations.html#compatibility-between-elixir-and-erlang-otp) sempre que for alterar as versões de ambos.

Para nosso exemplo, vamos usar a versão 1.6 do Elixir e a 20 do Erlang/OTP.

Comece instalando o Kerl

Como o Elixir depende de ter o Erlang instalado, vamos começar instalando o Kerl.

A instalação é simples, bastando baixar o binário, transformá-lo em executável e em seguida disponibilizá-lo em algum lugar do seu $PATH, que no meu caso foi o /usr/local/bin. Veja os passos:

curl -O https://raw.githubusercontent.com/kerl/kerl/master/kerl
mv kerl /usr/local/bin/
chmod a+x /usr/local/bin/kerl

Usuários do Windows devem instalar o Git For Windows e usar o Git Bash para que seja possível conseguir rodar o comando acima. Isso é o que eu imagino pois não cheguei a testar no Windows. 🙂

Agora, de posse do Kerl, vamos listar todas as versões disponíveis do Erlang que podemos instalar.

kerl list releases

A saída deve ser algo como isso…

# kerl list releases               
R10B-0
R10B-10
R10B-1a
R10B-2
R10B-3
R10B-4
R10B-5
R10B-6
R10B-7
R10B-8
...
19.0
19.1
19.2
19.3
20.0
20.1
20.2
20.3
21.0
Run '/usr/local/bin/kerl update releases' to update this list from erlang.org

O próximo passo é algo que pode parecer estranho inicialmente, pois vamos precisar criar um build da versão antes de instalar. Então vamos rodar…

kerl build 20.3 20.3

Perceba que a sintax repete duas vezes o número da versão. Isso na verdade é por conta de quando vamos criar um build nós damos um nome, e nesse caso, para a versão 20.3 o nome será 20.3. Note que isso permite você ter vários builds de uma mesma versão. Após o comando anterior, a saída deve ser algo assim…

# kerl build 20.3 20.3
Downloading otp_src_20.3.tar.gz to /root/.kerl/archives
######################################################################## 100.0%
Getting checksum file from erlang.org…
######################################################################## 100.0%
Verifying archive checksum…
Checksum verified (a683c8c0aacfe0305c4bf47b3abfde6a)
Extracting source code
Building Erlang/OTP 20.3 (20.3), please wait…
APPLICATIONS DISABLED (See: /root/.kerl/builds/20.3/otp_build_20.3.log)
* jinterface : No Java compiler found
* odbc : ODBC library — link check failed
APPLICATIONS INFORMATION (See: /root/.kerl/builds/20.3/otp_build_20.3.log)
* wx : wxWidgets not found, wx will NOT be usable
DOCUMENTATION INFORMATION (See: /root/.kerl/builds/20.3/otp_build_20.3.log)
* documentation :
* xsltproc is missing.
* fop is missing.
* xmllint is missing.
* The documentation can not be built.
Erlang/OTP 20.3 (20.3) has been successfully built

Após o build, podemos listar os builds já efetuados.

# kerl list builds
20.3,20.3

Agora eu temos o build, podemos instalar, informando um local de instalação

kerl install 20.3 ~/kerl/20.3

A saída deve ser algo assim…

# kerl install 20.3 ~/kerl/20.3
Installing Erlang/OTP 20.3 (20.3) in /root/kerl/20.3...
You can activate this installation running the following command:
. /root/kerl/20.3/activate
Later on, you can leave the installation typing:
kerl_deactivate

Conforme podemos ver no log de saída, devemos ativar a versão instalada, mas antes podemos consultar quais versões do Erlang estão instaladas, rodando…

kerl list installations

E a saída deve ser algo parecido com isso…

# kerl list installations
20.3 /root/kerl/20.3

Ok, agora vamos ativar a versão que instalamos. Lembre-se que o comando é relativo ao local que você instalou. No meu caso ficou assim…

. /root/kerl/20.3/activate

E por fim, verifique se o Erlang está ativo.

erl -version
Erlang (SMP,ASYNC_THREADS,HIPE) (BEAM) emulator version 9.3

É certo que o uso do Kerl é um pouco diferente pra quem vem do RVM/Rbenv, mas nada que assuste. 🙂 Além do mais, alterar o Erlang é algo que fazemos muito pouco quando usamos o Elixir.

A página do projeto é essa https://github.com/kerl/kerl, onde pode-se consultar toda a documentação para a instalação e o uso caso.

Chegou a vez do Kiex!

Depois de ter o Erlang instalado, chegou a vez do Elixir através do Kiex.

A instalação é feita através do curl, então, mais uma vez, se você usa Windows acredito que só vai funcionar através do Git Bash.

Além disso, o site informa que os pré-requisitos são o bash, curl, erlang, git, make, openssl.

Após a verificar que você tem os pré-requisitos já instalados, rode essa única linha em seu terminal:

\curl -sSL https://raw.githubusercontent.com/taylor/kiex/master/install | bash -s

Isso fará com que o Kiex seja instalado em seu diretório $HOME/.kiex .

Após a instalação rode…

 source "$HOME/.kiex/scripts/kiex"

…ou reinicie o terminal para que o kiex seja carregado.

Se você prestou atenção é exatamente isso que o RVM do Ruby faz, ou seja, a ideia não muda em nada, e o melhor é que os comandos para uso são praticamente iguais.

Usando o Kiex

A primeira coisa que podemos fazer é saber quais versões estão disponíveis para a instalação. Para isso use:

kiex list known (ou kiex list releases)

O resultado deve ser algo parecido com isso…

# kiex list releases
Unknown Linux distribution
Getting the available releases from https://github.com/elixir-lang/elixir/releases
Known Elixir releases: 
0.7.2
0.8.0
0.8.1
0.8.2
0.8.3
0.9.0
0.9.1
0.9.2
0.9.3
0.10.0
0.10.1
...
1.5.3
1.6.0
1.6.0-rc.0
1.6.0-rc.1
1.6.1
1.6.2
1.6.3
1.6.4
1.6.5
1.6.6
1.7.0-rc.0
1.7.0-rc.1

Para instalar uma nova versão use…

kiex install 1.6.6

A saída deve ser algo assim…

kiex install 1.6.6
Unknown Linux distribution
Downloading elixir version 1.6.6
Installing elixir version 1.6.6
Already on 'master'
Your branch is up-to-date with 'origin/master'.
Switched to a new branch 'v1.6.6'
From https://github.com/elixir-lang/elixir
* tag v1.6.6 -> FETCH_HEAD
Already up-to-date.
cd lib/elixir && "/root/.kiex/builds/elixir-git/rebar" clean
==> elixir (clean)
rm -rf ebin
rm -rf lib/*/ebin
make[1]: Entering directory '/root/.kiex/builds/elixir-git'
rm -rf lib/*/_build/
rm -rf lib/*/tmp/
rm -rf lib/elixir/test/ebin/
rm -rf lib/mix/test/fixtures/deps_on_git_repo/
rm -rf lib/mix/test/fixtures/git_rebar/
rm -rf lib/mix/test/fixtures/git_repo/
rm -rf lib/mix/test/fixtures/git_sparse_repo/
rm -f erl_crash.dump
make[2]: Entering directory '/root/.kiex/builds/elixir-git'
rm -f man/elixir.1
rm -f man/elixir.1.bak
rm -f man/iex.1
rm -f man/iex.1.bak
make[2]: Leaving directory '/root/.kiex/builds/elixir-git'
make[1]: Leaving directory '/root/.kiex/builds/elixir-git'
==> elixir (compile)
Compiled src/elixir_parser.yrl
Compiled src/elixir_bootstrap.erl
...
Compiled src/elixir_parser.erl
==> bootstrap (compile)
warning: the VM is running with native name encoding of latin1 which may cause Elixir to malfunction as it expects utf8. Please ensure your locale is set to UTF-8 (which can be verified by running "locale" in your shell)
Compiled lib/elixir/lib/kernel.ex
...
Compiled lib/elixir/lib/kernel/utils.ex
warning: erlang:get_stacktrace/0 used in the wrong part of 'try' expression. (Use it in the block between 'catch' and 'end'.)
/root/.kiex/builds/elixir-git/lib/elixir/lib/exception.ex:1242
Compiled lib/elixir/lib/exception.ex
...
Compiled lib/elixir/lib/kernel/lexical_tracker.ex
==> elixir (compile)
warning: the VM is running with native name encoding of latin1 which may cause Elixir to malfunction as it expects utf8. Please ensure your locale is set to UTF-8 (which can be verified by running "locale" in your shell)
warning: the VM is running with native name encoding of latin1 which may cause Elixir to malfunction as it expects utf8. Please ensure your locale is set to UTF-8 (which can be verified by running "locale" in your shell)
warning: erlang:get_stacktrace/0 used in the wrong part of 'try' expression. (Use it in the block between catch' and 'end'.)
lib/exception.ex:1242
warning: use Dict is deprecated, use the Map module for working with maps or the Keyword module for working with keyword lists
lib/hash_dict.ex:11
make[1]: Entering directory '/root/.kiex/builds/elixir-git'
==> unicode (compile)
...
Generated iex app
==> elixir (compile)
==> elixir (install)
make install_man
make[1]: Entering directory '/root/.kiex/builds/elixir-git'
make clean_man
make[2]: Entering directory '/root/.kiex/builds/elixir-git'
rm -f man/elixir.1
rm -f man/elixir.1.bak
rm -f man/iex.1
rm -f man/iex.1.bak
make[2]: Leaving directory '/root/.kiex/builds/elixir-git'
make[1]: Leaving directory '/root/.kiex/builds/elixir-git'
Installed Elixir version 1.6.6
Load with:
kiex use 1.6.6
or load the elixir environment file with:
source $HOME/.kiex/elixirs/elixir-1.6.6.env

Conforme a dica que aparece no log, rode…

kiex use 1.6.6

Isso fará com que a versão 1.6.6 seja usada pelo sistema.

Por fim, rode o comando abaixo e confira que o Elixir já está funcionando.

# elixir --version
warning: the VM is running with native name encoding of latin1 which may cause Elixir to malfunction as it expects utf8. Please ensure your locale is set to UTF-8 (which can be verified by running "locale" in your shell)
Erlang/OTP 20 [erts-9.3] [source] [64-bit] [smp:1:1] [ds:1:1:10] [async-threads:10] [hipe] [kernel-poll:false]
Elixir 1.6.6 (compiled with OTP 20)

Nesse momento estamos com o Elixir em pleno funcionamento! 😉

O site do projeto do Kiex é esse https://github.com/taylor/kiex, e lá você encontrar os comandos para caso precise alterar, remover ou instalar novas versões, que praticamente foi o que fizemos aqui.

Enfim, espero que tenham gostado do post e se você ainda não usa o Elixir, aproveite esse post e comece agora!

Ahhh, e é claro, se você puder, curta nossa página no Facebook ou ainda siga-nos nas redes sociais e cadastrem-se em nossa newsletter semanal! 😉

Um forte abraço e até a próxima!