Começando com o Phoenix-framework

Instalação de esqueleto

Às vezes você quer uma instalação sem nada, exceto a configuração mínima do phoenix. O comando follow lhe dará isso.

mix phoenix.new web --no-brunch --no-ecto

Observação: Você deve ter instalado Elixir, Erlang, Hex, Mix e o arquivo Phoenix para instalação do esqueleto

Criando projeto Phoenix

Para criar seu primeiro projeto no framework Phoenix neste ponto você deve ter, Elixir, Erlang, Hex e o arquivo Phoenix instalado. Você também deve ter o PostgreSQL e o node.js instalados para construir um aplicativo padrão.

Abra o terminal ou prompt de comando e vá para o local em seu sistema de arquivos onde você deseja criar aplicativo. phoenix.new é o comando mix que irá criar um novo projeto para você. Supondo que o nome do nosso aplicativo seja hello_phoenix_world, digite

$ mix phoenix.new hello_phoenix_world

Alternativamente, podemos executar o mix phoenix.new de qualquer diretório para inicializar nosso aplicativo Phoenix. Phoenix aceitará um caminho absoluto ou relativo para o diretório do nosso novo projeto

$ mix phoenix.new /Users/username/work/elixir-projects/hello_phoenix_world

Resultado

mix phoenix.new hello_phoenix_world
* creating hello_phoenix_world/config/config.exs
* creating hello_phoenix_world/config/dev.exs
* creating hello_phoenix_world/config/prod.exs
...
* creating hello_phoenix_world/web/views/layout_view.ex
* creating hello_phoenix_world/web/views/page_view.ex

Fetch and install dependencies? [Yn]

O Phoenix irá gerar a estrutura de diretórios do seu projeto e criará todos os arquivos necessários para a aplicação. O Mix perguntará se você deseja instalar outras dependências necessárias. Vamos dizer sim a isso.

Fetch and install dependencies? [Yn] Y
* running mix deps.get
* running npm install && node node_modules/brunch/bin/brunch build

Depois que as dependências forem instaladas, a tarefa solicitará que você mude para o diretório do nosso projeto e inicie o aplicativo.

Move into your new project folder:

    $cd hello_phoenix_world

Agora você precisa configurar o nome de usuário e a senha do postgres, a menos que já esteja configurado com o useranme e a senha do postgres padrão. Edite seu arquivo config/dev.exs e defina o nome de usuário e a senha:

# config/dev.exs
config :hello_phoenix_world, HelloPhoenixWorld.Repo,
  adapter: Ecto.Adapters.Postgres,
  username: "postgres",
  password: "postgres",
  database: "hello_phoenix_world_dev",
  hostname: "localhost",
  pool_size: 10
  
Now, create the database with the ecto mix task:

    $ mix ecto.create

We have a working application! Run your Phoenix application:

    $ mix phoenix.server

You can also run your app inside IEx (Interactive Elixir) as:

    $ iex -S mix phoenix.server

Load `http://localhost:4000` into your browser and you will see the default landing page of your application.

Agora, vamos adicionar hello world ao aplicativo Phoenix. Abra o arquivo web/templates/page/index.html.eex e substitua o conteúdo pelo seguinte e salve o arquivo:

<h2>Hello World</h2>

Se você não saiu do servidor, o novo código será compilado automaticamente e seu navegador deverá exibir a mensagem “Hello World”.

Agora você pode [criar recurso CRUD](https://www.wikiod.com/pt/phoenix-framework/comecando-com-o-phoenix-framework#Gerando recursos para um modelo ).

Finalmente, para sair do servidor, digite ctrl-c crtl-c (pressione a tecla control e a tecla c juntas) duas vezes seguidas.

Instalação

Phoenix framework é escrito em Elixir, e o próprio Elixir é baseado na linguagem Erlang e aproveita a VM Erlang, conhecida por executar sistemas de baixa latência, distribuídos e tolerantes a falhas. Ambas as linguagens são necessárias para usar o framework phoenix. Seguindo o passo a seguir para instalar o framework phoenix:

1. Instale o Elixir em sua máquina. Veja Instalação do Elixir e como instalar o guia do Elixir.

2. Instale o gerenciador de pacotes Hex. Hex é uma ferramenta necessária para executar um aplicativo Phoenix e instalar quaisquer dependências extras que possamos precisar ao longo do caminho. No seu terminal ou janela de controle de comando, digite:

$ mix local.hex

Este comando instalará ou atualizará o Hex, se você já o tiver.

3. Instale o Erlang em sua máquina. Sem Erlang, o código do Elixir não será compilado porque o Elixir usa a VM do Erlang para compilação do código. Quando você instalar o Elixir, você provavelmente instalou o Erlang também, mas se não for o caso, siga estas instruções no guia do Elixir para instalar o Erlang. No entanto, se você possui um sistema baseado em Debian, pode ser necessário instalar explicitamente o Erlang.

$ wget https://packages.erlang-solutions.com/erlang-solutions_1.0_all.deb && sudo dpkg -i erlang-solutions_1.0_all.deb
$ sudo apt-get update
$ sudo apt-get install esl-erlang

4. Instale o framework phoenix em sua máquina. Assim que tivermos Elixir e Erlang, estaremos prontos para instalar o arquivo Phoenix Mix. Um arquivo Mix é um arquivo Zip que contém um aplicativo, bem como seus arquivos BEAM compilados. Ele está vinculado a uma versão específica do aplicativo. O arquivo é o que usaremos para gerar um novo aplicativo Phoenix básico a partir do qual podemos construir. Aqui está o comando para instalar o arquivo Phoenix:

$ mix archive.install https://github.com/phoenixframework/archives/raw/master/phoenix_new.ez

Você pode baixar pacotes manualmente, se o comando acima não funcionar corretamente para você. Baixe os pacotes para o seu sistema de arquivos arquivos Phoenix e execute o seguinte comando

mix archive.install /path/to/local/phoenix_new.ez

5 Plug, Cowboy e Ecto são componentes do framework Phoenix, eles serão instalados automaticamente pelo mix, se você deixar o mix instalar suas dependências, quando você criar os projetos Phoenix pela primeira vez. Além disso, se você não permitir que o mix baixe esses componentes, o mix lhe dirá como fazer isso mais tarde.

6. Instale o Node.js (não menos que v5.0.0) em sua máquina. Esta é uma dependência opcional. Node.js é necessário para instalar dependências brunch.io. Brunch.io é usado pelo Phoenix para compilar ativos estáticos (javascript, css, etc), por padrão.

Podemos obter o node.js da página de download. Ao selecionar um pacote para download, é importante observar que o Phoenix requer a versão 5.0.0 ou superior.

Os usuários do Mac OS X também podem instalar o node.js via homebrew.

Observação: io.js, que é uma plataforma compatível com npm originalmente baseada em Node.js, não funciona com Phoenix.

Os usuários do Debian/Ubuntu podem ver um erro parecido com este:

sh: 1: node: not found
npm WARN This failure might be due to the use of legacy binary "node"

Isso se deve ao fato de o Debian ter binários conflitantes para o nó: veja a discussão sobre a seguinte pergunta SO

http://stackoverflow.com/questions/21168141/cannot-install-packages-using-node-package-manager-in-ubuntu

Existem duas opções para corrigir esse problema:

instale o nodejs-legacy:

$ apt-get install nodejs-legacy

ou criar um link simbólico

$ ln -s /usr/bin/nodejs /usr/bin/node

7 Instale o Banco de Dados (PostgreSQL) em sua máquina. O Phoenix configura os aplicativos para usá-lo por padrão, mas podemos alternar para MySQL passando o sinalizador --database mysql ao criar um novo aplicativo. O wiki do PostgreSQL tem guias de instalação para vários sistemas diferentes.

O Postgrex é uma dependência direta do Phoenix e será usado para criar modelos. Postgrex será instalado automaticamente junto com o restante das dependências quando você criar e iniciar o projeto Phoenix.

8 inotify-tools (para usuários linux) Este é um observador do sistema de arquivos somente para Linux que o Phoenix usa para recarregar o código ao vivo. (Usuários de Mac OS X ou Windows podem ignorá-lo com segurança.)

Os usuários do Linux precisam instalar essa dependência. Consulte o inotify-tools wiki para obter instruções de instalação específicas da distribuição.

Executando Elixir/Phoenix no OSX

Elixir/Fênix

Instale o Homebrew primeiro:

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Em seguida, executar o brew install elixir instalará o Elixir e sua dependência - Erlang.

Instale mix com mix local.hex.

Instale o Phoenix conforme as instruções:

mix archive.install https://github.com/phoenixframework/archives/raw/master/phoenix_new.ez

Node.js

Você pode instalar e gerenciar suas versões do Node.js com o NVM. Instale nvm com:

curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.31.4/install.sh | bash

Se curl não estiver disponível, você pode instalá-lo com brew install curl. Então corra:

nvm install node

para baixar e compilar a versão mais recente do Node.js.

Base de dados

Baixe Postgres.app e execute-o. Quando você cria seu projeto Phoenix, em seu arquivo config/dev.exs, você só precisa fornecer um nome para seu banco de dados - o adaptador usará valores padrão para o resto:

config :myphoenixapp, MyPhoenixApp.Repo,
  adapter: Ecto.Adapters.Postgres,
  database: "myphoenixapp_dev",
  hostname: "localhost",
  pool_size: 10

Gerando recursos para um modelo

Para gerar esquema, visão, controlador, arquivo de migração para o repositório, modelos CRUD padrão e arquivos de teste para um modelo (como um scaffolding no Rails), pode-se usar a tarefa mix phoenix.gen.html como esta:

mix phoenix.gen.html Book books title note:text pages:integer author_id:references:authors

Onde Book é o nome do módulo, books é a forma plural usada para esquema, seguido pelos campos de recursos: title (string por padrão), note (campo de texto), pages (inteiro), author_id que cria uma associação belongs_to com o modelo Author.

Gerar documentação do projeto →