phoenix-framework Tutorial
Empezando con phoenix-framework

Observaciones

Versiones

Instalación

El marco de Phoenix está escrito en Elixir , y el propio Elixir se basa en el lenguaje Erlang y aprovecha la máquina virtual de Erlang, conocida por ejecutar sistemas de baja latencia, distribuidos y tolerantes a fallas. Ambos lenguajes son requeridos para usar el framework phoenix. Siguiendo el siguiente paso para instalar el framework phoenix:

1. Instale Elixir en su máquina. Consulte Instalación de Elixir y cómo instalar la guía de Elixir .

2. Instale el gestor de paquetes Hex . Hex es una herramienta necesaria para ejecutar una aplicación de Phoenix e instalar las dependencias adicionales que podamos necesitar en el camino. Desde su terminal o ventana de control de comando, escriba:

$ mix local.hex

Este comando instalará o actualizará Hex, si ya lo tiene.

3. Instale Erlang en su máquina. Sin Erlang, el código de Elixir no se compilará porque Elixir usa la máquina virtual de Erlang para la compilación de código. Cuando instale Elixir, es probable que también haya instalado Erlang, pero si no es así, siga estas instrucciones en la guía de Elixir para instalar Erlang. Sin embargo, si tiene un sistema basado en Debian, es posible que deba instalar Erlang explícitamente.

$ 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 el marco de Phoenix en su máquina. Una vez que tengamos Elixir y Erlang, estamos listos para instalar el archivo Phoenix Mix. Un archivo Mix es un archivo Zip que contiene una aplicación así como sus archivos BEAM compilados. Está vinculado a una versión específica de la aplicación. El archivo es lo que usaremos para generar una nueva aplicación básica de Phoenix, a partir de la cual podemos construir. Aquí está el comando para instalar el archivo Phoenix:

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

Puede descargar paquetes manualmente, si el comando anterior no funciona correctamente para usted. Descargue paquetes a su sistema de archivos de archivos Phoenix y ejecute el siguiente comando

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

5 Plug, Cowboy y Ecto son componentes del marco de Phoenix, se instalarán automáticamente por mezcla, si dejas que Mix instale sus dependencias, cuando primero crearás proyectos de Phoenix. Además, si no permite que la mezcla descargue estos componentes, la combinación le indicará cómo hacerlo más adelante.

6. Instale Node.js (no menos que v5.0.0) en su máquina. Esta es una dependencia opcional . Node.js es necesario para instalar las dependencias de brunch.io . Phoenix utiliza Brunch.io para compilar activos estáticos (javascript, css, etc.), por defecto.

Podemos obtener node.js desde la página de descarga . Al seleccionar un paquete para descargar, es importante tener en cuenta que Phoenix requiere la versión 5.0.0 o superior.

Los usuarios de Mac OS X también pueden instalar node.js a través de homebrew .

Nota: no se sabe si io.js, que es una plataforma compatible con npm originalmente basada en Node.js, funciona con Phoenix.

Los usuarios de Debian / Ubuntu pueden ver un error que se ve así:

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

Esto se debe a que Debian tiene binarios en conflicto para el nodo: vea la discusión sobre la siguiente pregunta SO

No se pueden instalar paquetes usando el administrador de paquetes de nodo en Ubuntu

Hay dos opciones para solucionar este problema, ya sea:

instalar nodejs-legacy:

$ apt-get install nodejs-legacy

o crear un enlace simbólico

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

7 Instale la base de datos ( PostgreSQL ) en su máquina. Phoenix configura las aplicaciones para usarlas de forma predeterminada, pero podemos cambiar a MySQL al pasar la --database mysql al crear una nueva aplicación. El wiki de PostgreSQL tiene guías de instalación para varios sistemas diferentes.

Postgrex es una dependencia directa de Phoenix y se utilizará para crear modelos. Postgrex se instalará automáticamente junto con el resto de dependencias cuando creará e iniciará el proyecto Phoenix.

8 inotify-tools (para usuarios de Linux) Este es un observador del sistema de archivos solo para Linux que Phoenix usa para la recarga de código en vivo. (Los usuarios de Mac OS X o Windows pueden ignorarlo).

Los usuarios de Linux necesitan instalar esta dependencia. Consulte la wiki de herramientas de inotificación para obtener instrucciones de instalación específicas de distribución.

Instalación de esqueleto

A veces desea una instalación sin nada excepto la configuración mínima de Phoenix. El siguiente comando te dará eso.

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

Nota: debe haber instalado Elixir, Erlang, Hex, Mix y el archivo Phoenix para la instalación de esqueleto

Creando proyecto Phoenix

Para crear su primer proyecto en el marco de Phoenix en este punto , debe tener instalados Elixir, Erlang, Hex y el archivo de Phoenix. También debe tener PostgreSQL y node.js instalados para crear una aplicación predeterminada.

Abra el terminal o el símbolo del sistema y vaya a la ubicación en su sistema de archivos donde desea crear la aplicación . phoenix.new es el comando mix que creará un nuevo proyecto para ti. Suponiendo que el nombre de nuestra aplicación es hello_phoenix_world , escriba

$ mix phoenix.new hello_phoenix_world

Alternativamente , podemos ejecutar mix phoenix.new desde cualquier directorio para iniciar nuestra aplicación Phoenix. Phoenix aceptará una ruta absoluta o relativa para el directorio de nuestro nuevo proyecto

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

Salida

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]

Phoenix generará la estructura de directorios para su proyecto y creará todos los archivos necesarios para la aplicación. Mix le preguntará si desea instalar otras dependencias requeridas . Digamos que sí a eso.

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

Una vez que se instalen las dependencias , la tarea le pedirá que cambie a nuestro directorio de proyecto e inicie la aplicación.

Move into your new project folder:

    $cd hello_phoenix_world

Ahora debe configurar el nombre de usuario y la contraseña de postgres, a menos que ya esté configurado con la contraseña y el usuario de postgres predeterminados. Edite su archivo config/dev.exs y configure el nombre de usuario y la contraseña:

# 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.

Ahora, vamos a agregar hola mundo a la aplicación Phoenix. Abra el archivo web/templates/page/index.html.eex y reemplace los contenidos con lo siguiente y guarde el archivo:

<h2>Hello World</h2>

Si no ha abandonado el servidor, el nuevo código se compilará automáticamente y su navegador ahora debería mostrar su mensaje "Hola mundo".

Ahora puede crear un recurso CRUD .

Finalmente, para salir del servidor, escriba ctrl-c crtl-c (presione la control key y la tecla c juntas) dos veces seguidas.

Ejecutando Elixir / Phoenix en OSX

Elixir / fénix

Instale Homebrew primero:

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

Luego, ejecutar brew install elixir instalará tanto el elixir como su dependencia: Erlang.

Instalar la mezcla con la mix local.hex .

Instale Phoenix según las instrucciones:

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

Node.js

Puede instalar y administrar sus versiones de Node.js con NVM. Instala nvm con:

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

Si no está disponible el curl , puede instalarlo con el brew install curl . Entonces corre:

nvm install node

para descargar y compilar y la última versión de Node.js.

Base de datos

Descarga Postgres.app y ejecútalo . Cuando cree su proyecto Phoenix, en su archivo config/dev.exs , solo debe proporcionar un nombre para su base de datos; el adaptador usará los valores predeterminados para el resto:

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

Generando recursos para un modelo.

Para generar el esquema, la vista, el controlador, el archivo de migración para el repositorio, las plantillas de CRUD predeterminadas y los archivos de prueba para un modelo (como un andamio en Rails) se puede usar la tarea de mezcla phoenix.gen.html como esta:

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

Donde Book es el nombre del módulo, books se forma plural se utiliza para el esquema, seguida de campos de recursos: title (cadena por defecto), note (campo de texto), pages (entero), author_id que crea un belongs_to asociación con el modelo de Autor.