phoenix-framework Tutoriel
Démarrer avec phoenix-framework

Remarques

Versions

Installation

Phoenix Framework est écrit en Elixir , et Elixir lui-même est basé sur le langage Erlang et exploite la machine virtuelle Erlang, connue pour exécuter des systèmes à faible latence, distribués et tolérants aux pannes. Les deux langues sont requises pour utiliser le framework Phoenix. Après l'étape suivante pour installer le framework phoenix:

1. Installez Elixir sur votre machine. Voir Installation Elixir et comment installer le guide Elixir .

2. Installez le gestionnaire de paquets Hex . Hex est un outil nécessaire pour faire fonctionner une application Phoenix et installer les dépendances supplémentaires dont nous pourrions avoir besoin tout au long du processus. À partir de votre fenêtre de contrôle de terminal ou de commande, tapez:

$ mix local.hex

Cette commande va installer ou mettre à jour Hex, si vous en avez déjà.

3. Installez Erlang sur votre machine. Sans Erlang, le code Elixir ne sera pas compilé car Elixir utilise la VM d'Erlang pour la compilation de code. Lorsque vous installerez Elixir, vous avez probablement installé Erlang également, mais si ce n'est pas le cas, suivez ces instructions sur le guide Elixir pour installer Erlang. Cependant, si vous utilisez un système basé sur Debian, vous devrez peut-être installer explicitement 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. Installez le framework Phoenix sur votre machine. Une fois que nous avons Elixir et Erlang, nous sommes prêts à installer l’archive Phoenix Mix. Une archive Mix est un fichier Zip contenant une application ainsi que ses fichiers BEAM compilés. Il est lié à une version spécifique de l'application. L'archive est ce que nous allons utiliser pour générer une nouvelle application Phoenix de base à partir de laquelle nous pouvons construire. Voici la commande pour installer l'archive Phoenix:

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

Vous pouvez télécharger les paquets manuellement, si la commande ci-dessus ne fonctionne pas correctement pour vous. Téléchargez des packages vers vos archives de système de fichiers Phoenix et exécutez la commande suivante

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

5 Plug, Cowboy et Ecto sont des composants du framework Phoenix, ils seront installés automatiquement par mix, si vous laissez le mix installer ses dépendances, lorsque vous créerez d’abord des projets Phoenix. En outre, si vous ne permettez pas à Mix de télécharger ces composants, le mix vous indiquera comment procéder plus tard.

6. Installez Node.js (pas moins que la version 5.0.0) sur votre machine. Ceci est une dépendance facultative . Node.js est requis pour installer les dépendances brunch.io . Brunch.io est utilisé par Phoenix pour compiler des ressources statiques (javascript, css, etc.), par défaut.

Nous pouvons obtenir node.js de la page de téléchargement . Lors de la sélection d'un package à télécharger, il est important de noter que Phoenix requiert la version 5.0.0 ou supérieure.

Les utilisateurs de Mac OS X peuvent également installer node.js via homebrew .

Remarque: io.js, qui est une plate-forme compatible npm basée à l'origine sur Node.js, n'est pas connue pour fonctionner avec Phoenix.

Les utilisateurs Debian / Ubuntu peuvent voir une erreur qui ressemble à ceci:

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

Ceci est dû au fait que Debian a des binaires en conflit pour le noeud: voir la discussion sur la question SO suivante

Impossible d'installer les packages à l'aide du gestionnaire de packages de nœuds dans Ubuntu

Il existe deux options pour résoudre ce problème:

installer nodejs-legacy:

$ apt-get install nodejs-legacy

ou créer un lien symbolique

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

7 Installez la base de données ( PostgreSQL ) sur votre machine. Phoenix configure les applications pour l'utiliser par défaut, mais nous pouvons passer à MySQL en passant l' --database mysql lors de la création d'une nouvelle application. Le wiki PostgreSQL contient des guides d'installation pour différents systèmes.

Postgrex est une dépendance directe de Phoenix et sera utilisée pour créer des modèles. Postgrex sera automatiquement installé avec le reste des dépendances lorsque vous créerez et démarrerez un projet Phoenix.

8 inotify-tools (pour les utilisateurs linux) Il s'agit d'un observateur de système de fichiers Linux uniquement que Phoenix utilise pour le rechargement de code en direct. (Les utilisateurs de Mac OS X ou Windows peuvent l’ignorer en toute sécurité.)

Les utilisateurs de Linux doivent installer cette dépendance. Veuillez consulter le wiki inotify-tools pour obtenir des instructions d'installation spécifiques à la distribution.

Installation du squelette

Parfois, vous voulez une installation sans rien sauf la configuration minimale de Phoenix. La commande suivante vous donnera cela.

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

Remarque: Vous devez avoir installé Elixir, Erlang, Hex, Mix et l’archive Phoenix pour l’installation du squelette.

Création du projet Phoenix

Pour créer votre premier projet dans le framework Phoenix, vous devez avoir installé Elixir, Erlang, Hex et les archives Phoenix. PostgreSQL et node.js doivent également être installés pour créer une application par défaut.

Ouvrez le terminal ou l'invite de commande et accédez à l'emplacement sur votre système de fichiers où vous souhaitez créer une application . phoenix.new est la commande de mixage qui créera un nouveau projet pour vous. En supposant que le nom de notre application est hello_phoenix_world , tapez

$ mix phoenix.new hello_phoenix_world

Alternativement , nous pouvons exécuter mix phoenix.new à partir de n'importe quel répertoire afin d'amorcer notre application Phoenix. Phoenix acceptera un chemin absolu ou relatif pour le répertoire de notre nouveau projet

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

Sortie

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 générera la structure de répertoires de votre projet et créera tous les fichiers requis pour l'application. Mix vous demandera si vous souhaitez installer d'autres dépendances requises . Disons oui à ça.

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

Une fois les dépendances installées , la tâche vous demandera de changer dans notre répertoire de projet et de lancer l'application.

Move into your new project folder:

    $cd hello_phoenix_world

Vous devez maintenant configurer le nom d'utilisateur et le mot de passe postgres à moins que celui-ci ne soit déjà configuré avec le mot de passe postgres useranme et postgres par défaut. Modifiez votre fichier config/dev.exs et définissez le nom d'utilisateur et le mot de passe:

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

Maintenant, permet d'ajouter hello world à l'application Phoenix. Ouvrez le fichier web/templates/page/index.html.eex et remplacez le contenu par le suivant et enregistrez le fichier:

<h2>Hello World</h2>

Si vous n'avez pas quitté le serveur, le nouveau code sera automatiquement compilé et votre navigateur devrait maintenant afficher votre message "Hello World".

Vous pouvez maintenant créer une ressource CRUD .

Enfin, pour sortir du serveur, tapez ctrl-c crtl-c (appuyez crtl-c sur la control key crtl-c et la touche c ).

Courir Elixir / Phoenix sur OSX

Elixir / Phoenix

Installez d'abord Homebrew :

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

Ensuite, le brew install elixir et installera Elixir et sa dépendance - Erlang.

Installez le mix avec mix local.hex .

Installez Phoenix selon les instructions:

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

Node.js

Vous pouvez installer et gérer vos versions Node.js avec NVM. Installez nvm avec:

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

Si curl n'est pas disponible, vous pouvez l'installer avec une brew install curl . Puis lancez:

nvm install node

pour télécharger et compiler et la dernière version de Node.js.

Base de données

Téléchargez Postgres.app et lancez-le. Lorsque vous créez votre projet Phoenix, dans votre fichier config/dev.exs , il vous suffit de fournir un nom à votre base de données - l'adaptateur utilisera les valeurs par défaut pour le reste:

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

Générer des ressources pour un modèle

Pour générer un schéma, une vue, un contrôleur, un fichier de migration pour le référentiel, des modèles CRUD par défaut et des fichiers de test pour un modèle (comme un échafaudage dans Rails), vous pouvez utiliser la tâche de mixage phoenix.gen.html :

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

Où Book est le nom du module, books est la forme plurielle utilisée pour le schéma, suivie des champs de ressources: title (chaîne par défaut), note (champ de texte), pages (entier), author_id qui crée une association belongs_to avec le modèle Author.