Primeros pasos con phoenix-framework

Instalación del esqueleto

A veces, desea una instalación sin nada más que la configuración mínima de phoenix. El siguiente comando te dará eso.

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

Nota: Debe tener instalado Elixir, Erlang, Hex, Mix y el archivo Phoenix para la instalación del esqueleto

Creando el proyecto Phoenix

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

Abra la 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 de mezcla que creará un nuevo proyecto para usted. Asumiendo 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

Producción

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 que instale 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 las dependencias están instaladas, la tarea le pedirá que cambie a nuestro directorio de proyectos 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 el nombre de usuario y la contraseña 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, agreguemos hola mundo a la aplicación Phoenix. Abra el archivo web/templates/page/index.html.eex y reemplace el contenido con lo siguiente y guarde el archivo:

<h2>Hello World</h2>

Si no ha salido del servidor, el nuevo código se compilará automáticamente y su navegador ahora debería mostrar su mensaje “Hello World”.

Ahora puede [crear un recurso CRUD](https://www.wikiod.com/es/phoenix-framework/primeros-pasos-con-phoenix-framework#Generación de recursos para un modelo. ).

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

Instalación

Phoenix framework está escrito en Elixir, y Elixir en sí está basado en el lenguaje Erlang y aprovecha la máquina virtual Erlang, conocida por ejecutar sistemas de baja latencia, distribuidos y tolerantes a fallas. Se requieren ambos idiomas para usar phoenix framework. Siguiendo el siguiente paso para instalar phoenix framework:

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

2. Instale el administrador de paquetes Hex. Hex es una herramienta necesaria para ejecutar una aplicación de Phoenix e instalar cualquier dependencia adicional que podamos necesitar en el camino. Desde su terminal o ventana de control de comandos, escriba:

$ mix local.hex

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

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 compilar el código. Cuando instale Elixir, probablemente también haya instalado Erlang, pero si no es el caso, 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 phoenix framework 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 archivos de Phoenix y ejecute el siguiente comando

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

5 Plug, Cowboy y Ecto son componentes del framework Phoenix, se instalarán automáticamente mediante mix, si permite que mix instale sus dependencias, cuando cree proyectos Phoenix por primera vez. Además, si no permite que mix descargue estos componentes, mix le dirá cómo hacerlo más adelante.

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

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: io.js, que es una plataforma compatible con npm originalmente basada en Node.js, no funciona con Phoenix.

Los usuarios de Debian/Ubuntu pueden ver un error similar a este:

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

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

Hay dos opciones para solucionar este problema, ya sea:

instalar nodejs-heredado:

$ 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 pasando el indicador --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 cree e inicie el proyecto Phoenix.

8 herramientas de inotificación (para usuarios de Linux) Este es un observador del sistema de archivos solo para Linux que Phoenix usa para recargar código en vivo. (Los usuarios de Mac OS X o Windows pueden ignorarlo con seguridad).

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

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 Elixir como su dependencia: Erlang.

Instale la mezcla con mix local.hex.

Instale Phoenix según las instrucciones:

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

Nodo.js

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

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

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

nvm install node

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

Base de datos

Descargue Postgres.app y ejecútelo. Cuando crea su proyecto Phoenix, en su archivo config/dev.exs, solo necesita 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 CRUD predeterminadas y los archivos de prueba para un modelo (como un andamio en Rails), se puede usar la tarea mixta phoenix.gen.html como esta:

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

Donde Libro es el nombre del módulo, libros es la forma plural utilizada para el esquema, seguida de campos de recursos: título (cadena por defecto), nota (campo de texto), páginas (entero), autor_id que crea una asociación belongs_to con el modelo Autor.