Premiers pas avec Phoenix-Framework
Installation du squelette
Parfois, vous voulez une installation sans rien d’autre que la configuration minimale de Phoenix. La commande suivante vous le donnera.
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 à ce stade, ** vous devriez avoir **, Elixir, Erlang, Hex et l’archive Phoenix installés. Vous devez également avoir installé PostgreSQL et node.js pour créer une application par défaut.
Ouvrez le terminal ou l’invite de commande et accédez à l’emplacement de 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, puis tapez
$ mix phoenix.new hello_phoenix_world
** Alternativement **, nous pouvons exécuter mix phoenix.new à partir de n’importe quel répertoire afin de démarrer 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
Production
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 nécessaires à l’application. Mix vous demandera si vous souhaitez qu’il installe d’autres dépendances requises. Disons oui à cela.
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 vous rendre dans notre répertoire de projet et de démarrer 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 qu’ils ne soient déjà configurés avec le nom d’utilisateur et le mot de passe 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, ajoutons hello world à l’application Phoenix. Ouvrez le fichier web/templates/page/index.html.eex et remplacez le contenu par ce qui suit 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](https://www.wikiod.com/fr/phoenix-framework/premiers-pas-avec-phoenix-framework#Génération de ressources pour un modèle ).
Enfin, pour quitter le serveur, tapez ctrl-c crtl-c (appuyez simultanément sur la touche control et la touche c) deux fois de suite.
Installation
[Phoenix framework][1] est écrit en [Elixir][2], et Elixir lui-même est basé sur le langage [Erlang][3] 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. Suivez l’étape suivante pour installer le framework Phoenix :
1. Installez Elixir sur votre machine. Voir [Installation Elixir] [4] et comment [installer le guide Elixir] [5].
2. Installez le gestionnaire de paquets Hex. [Hex][6] est un outil nécessaire pour faire fonctionner une application Phoenix et pour installer toutes les dépendances supplémentaires dont nous pourrions avoir besoin en cours de route. Depuis votre terminal ou votre fenêtre de contrôle de commande, tapez :
$ mix local.hex
Cette commande installera ou mettra à jour Hex, si vous l’avez déjà fait.
3. Installez Erlang sur votre machine. Sans Erlang, le code Elixir ne compilera pas car Elixir utilise la VM d’Erlang pour la compilation du code. Lorsque vous installerez Elixir, vous avez probablement également installé Erlang, mais si ce n’est pas le cas, suivez [ces instructions] [7] sur le guide Elixir pour installer Erlang. Cependant, si vous avez 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 Phoenix Framework 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 qui contient 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 utiliserons pour générer une nouvelle application Phoenix de base à partir de laquelle nous pourrons 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 packages manuellement si la commande ci-dessus ne fonctionne pas correctement pour vous. Téléchargez les packages sur votre système de fichiers [archives Phoenix] [8] 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 pour la première fois des projets Phoenix. De plus, si vous n’autorisez pas Mix à télécharger ces composants, Mix vous dira comment procéder plus tard.
6. Installez Node.js (au moins v5.0.0) sur votre machine. Il s’agit d’une dépendance facultative. [Node.js][9] est nécessaire pour installer les dépendances [brunch.io][10]. Brunch.io est utilisé par Phoenix pour compiler des assets statiques (javascript, css, etc), par défaut.
Nous pouvons obtenir node.js à partir de la [page de téléchargement][11]. Lors de la sélection d’un package à télécharger, il est important de noter que Phoenix nécessite la version 5.0.0 ou supérieure.
Les utilisateurs de Mac OS X peuvent également installer node.js via [homebrew][12].
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 de 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"
Cela est dû au fait que Debian a des fichiers binaires en conflit pour le nœud : voir la discussion sur la question SO suivante
http://stackoverflow.com/questions/21168141/cannot-install-packages-using-node-package-manager-in-ubuntu
Il existe deux options pour résoudre ce problème, soit :
installez 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][13]) sur votre machine. Phoenix configure les applications pour l’utiliser par défaut, mais nous pouvons passer à [MySQL][14] en passant le drapeau --database mysql lors de la création d’une nouvelle application. Le wiki PostgreSQL contient des [guides d’installation][15] pour un certain nombre de systèmes différents.
Postgrex est une dépendance directe de Phoenix et il sera utilisé pour créer des modèles. Postgrex sera automatiquement installé avec le reste des dépendances lorsque vous créerez et démarrerez le projet Phoenix.
8 outils inotify (pour les utilisateurs Linux) Il s’agit d’un observateur de système de fichiers Linux uniquement utilisé par Phoenix 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][16] pour les instructions d’installation spécifiques à la distribution.
[1] : http://www.phoenixframework.org/ [2] : http://elixir-lang.org/ [3] : https://www.erlang.org/ [4] : https://www.wikiod.com/fr/elixir/installation [5] : http://elixir-lang.org/getting-started/introduction.html#installation [6] : https://hex.pm/ [7] : http://elixir-lang.org/install.html#installing-erlang [8] : https://github.com/phoenixframework/archives [9] : https://nodejs.org/en/ [10] : http://brunch.io/ [11] : https://nodejs.org/en/download/ [12] : http://brew.sh/ [13] : https://www.postgresql.org/ [14] : https://www.mysql.com/ [15] : https://wiki.postgresql.org/wiki/Detailed_installation_guides [16] : https://github.com/rvoicilas/inotify-tools/wiki
Exécuter Elixir/Phoenix sur OSX
Élixir / Phénix
Installez d’abord [Homebrew][1] :
/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
Ensuite, l’exécution de “brew install elixir” installera à la fois 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 de Node.js avec NVM. Installez [nvm][2] 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 brew install curl. Exécutez ensuite :
nvm install node
pour télécharger et compiler la dernière version de Node.js.
Base de données
Téléchargez [Postgres.app][3] et exécutez-le. Lorsque vous créez votre projet Phoenix, dans votre fichier config/dev.exs, il vous suffit de fournir un nom pour 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
[1] : http://brew.sh/ [2] : https://github.com/creationix/nvm [3] : http://postgresapp.com/
Génération de 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), on peut utiliser la tâche de mixage “phoenix.gen.html” comme ceci :
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, suivi des champs de ressource : 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.