Jak vytvořit více webových aplikací pomocí Elixiru díky deštníku - část 2: Nastavení projektu

(Wannabe) průvodce, jak se naučit vytvářet webové aplikace s Elixir 1.9, Phoenix 1.4, Docker (pro vývoj), Git (včetně submodulů) k verzi jednotlivých aplikací, PostgresQL, Redis, volání API a nasazení.

Tato příručka je určena vývojářům, kteří mají za sebou několik projektů a jsou ochotni zkusit Elixir. Tato druhá část vám řekne, jak nastavit projekt.

souhrn

  • Proč Elixir?
  • Nastavte projekt
  • Vytvořte uživatele pro web administrátora, část 1: Bootstrap, entita a testy
  • Vytvořte uživatele pro web administrátora, část 2: zabezpečení a hesla
  • Nasadit aplikaci Deštník
  • Vytvořte API
  • Vytvořte agregační službu
  • Zpracovávejte kanál pro aplikace v reálném čase

Nový! Zdroje průvodce nyní najdete zde: https://github.com/aridjar-umbrella-guide/medium_umbrella! Upgraduji je současně s upgradem průvodce!

V této kapitole se podíváme, jak nainstalovat, vytvořit a nakonfigurovat zastřešující aplikaci a její podřízenou aplikaci, ukotvit a uložit každý projekt do úložiště git.

V této příručce se doporučuje vědět, jak vytvořit úložiště git, protože prozkoumáme pouze část subitule git v přidružené části. Na doku nebudete potřebovat žádné znalosti.

Nainstalujte Elixir, Docker a Node

Pro ty z vás, kteří neznají dokovací stanici, bychom mohli vytvořit soubor Dockerfile a použít jej k provádění všech instalací a příkazů spojených s jazykem z kontrolovaného virtuálního prostředí. Ale to by donutilo každého, aby používal dokovací stanici, a někteří z vás se tomu možná budou chtít vyhnout.

Nejprve tedy nainstalujte Elixir podle tohoto průvodce: Instalace Elixiru. Jakmile je hotovo, otevřete terminál a typ

$> mix -v

Měli byste mít podobný výstup:

Poznámka: Možná budete chtít zkontrolovat verzi Erland / OTP v ukotvitelném panelu, abyste se ujistili, že máte odpovídající verzi (jinak to může způsobit problém). Chcete-li tak učinit, přejděte do úložiště docker-elixir, vyberte nejnovější verzi (ve skutečnosti 1.9) a otevřete soubor s názvem Dockerfile. První řádek by měl informovat o použité verzi. Pokud máte jinou verzi, nainstalujte prosím Erlang.

Po instalaci Elixiru se o Phoenix postaráme. Jelikož je to hlavní rámec Elixiru, budeme jej používat k vytváření našich webových aplikací.

$> mix archive.install hex phx_new 1.4.2

Pokud to nefunguje, měli byste být schopni jej nainstalovat pomocí Githubu pomocí starého příkazu:

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

Pak si nainstalujte Docker.

Poznámka: není povinná, ale nemusím v této příručce poskytovat jiné způsoby, jak konfigurovat a zpracovávat různé věci, například databáze.

Jakmile je Docker nainstalován, restartujte prostředí a zadejte:

docker -v

Měli byste vidět verzi. Pokud tomu tak není, přidejte složku Docker na cestu $.

A konečně, pokud ještě nemáte ve svém počítači Node nainstalován a chcete jej mít, postupujte podle tohoto průvodce: install node.js. Není to však povinné, protože zkompilujeme a spustíme uzel a aktiva v kontejneru Docker.

Vytvořte aplikaci deštník

Nyní, když jsme nainstalovali vše, co potřebujeme, pojďme si trochu povídat o zastřešujících aplikacích:

Aplikace Elixir Umbrella definuje jednu nadřazenou aplikaci, která ukládá a spravuje sadu podřízených aplikací.

To znamená, že namísto vytváření více aplikací oddělených od ostatních bude každá aplikace propojena s ostatními prostřednictvím deštníku, což jim umožní využívat výhody mikro-služeb i monolitických aplikací.

Ale dost řeči! Chcete-li vytvořit zastřešující aplikaci, musíte zadat:

$> mix phx.new [destination_folder] --umbrella

Podívejme se podrobně na každé slovo:

  • mix je správce balíčků elixiru, jako NPM je pro JavaScript.
  • phx je klíčové slovo spojené s rámcem Phoenix.
  • nové vytvořit novou aplikaci. Pokud se o tom chcete dozvědět více, napište do příkazového řádku příkaz mix phx.new: zobrazí dokumentaci. Nové bez phx. v přední části vytvořte jednoduchou aplikaci Elixir, jak uvidíme později.
  • [destination_folder] je místo, kde má být aplikace.
Poznámka: Pokud se jedná o aplikaci zastřešující, vytvoří složku a za název přidá _umbrella.
  • --umbrella tell mix pro vytvoření aplikace pro deštníky.

V určitém okamžiku se tento příkaz zeptá, zda chcete načíst a nainstalovat závislosti. Pokud chcete použít ukotvitelný panel, není to povinné. Jinak zadejte Y a stiskněte enter.

Tento příkaz vytvoří aplikaci se dvěma složkami (aplikace a konfigurace) a několika soubory, včetně konfiguračních souborů pro více prostředí. Většina z nich jsou obyčejní (.gitignore, README.md ...).

Dva soubory, které možná neznáte, jsou .formatter.exs a mix.exs. Každý z nich je souborem Elixir Script (.exs). mix.exs zpracovává konfiguraci mixu pro tento projekt, zahrnuje popis, závislosti a někdy i jiné věci. O několika formátech budeme mluvit v několika odstavcích.

Jakmile příkaz udělal vše, co musel udělat, nesledujte to, co vám elixír doporučuje. Místo toho proveďte:

$> cd [destination_folder] _umbrella && rm -rf ./apps/*

Vymažete tím dvě aplikace, které pro nás vygenerovala společnost Phoenix, když jsme vytvořili aplikaci deštník. V závislosti na tom, co chcete, si je můžete nechat. Ale pokud jde o tohoto průvodce, nebudeme je používat: „web“, pokud jde o veřejnou aplikaci. Používám Angular na serveru Node a pravděpodobně také dáváte přednost něčemu, co bylo vytvořeno pro frontend, jako React nebo VueJS.

Chceme také upravit název aplikací, proto jsme také odstranili zadní část.

Poznámka: Někteří z vás mohou argumentovat, že bychom mohli hostit a sestavit projekt front end JS v aplikaci pro deštníky. A pravděpodobně máte pravdu, ale nechci trávit čas pochopením, jak to udělat, alespoň prozatím. Ale pokud víte, jak to udělat, napište střední článek, pošlete mi odkaz na něj a já to zveřejním zde! :)

Konečně .formatter.exs je soubor, který vám umožní použít příkaz formátu themix. Účelem je zformátovat každý soubor obsahující elixirový kód, takže se řídí stejnými pravidly pro psaní, takže je snadněji čte pro všechny.

Neměl bych váš kód hodně ovlivňovat, protože funkční jazyky nejsou tak přípustné jako iterační nebo objektové jazyky, zejména když se řídíme hlavní myšlenkou funkčního paradigmatu (spousta krátkých, čistých funkcí), ale může být užitečná v závislosti na situace.

Nyní vytvoříme 5 projektů uvnitř.

Chcete-li tak učinit, přejděte do složky aplikací:

$> cd aplikace
Varování !! Buďte opatrní: název každé složky, kterou vytvoříme, musí být stejný jako název úložiště git. Tím se vyhnete komplikacím a nadměrné zbytečné konfiguraci.

Tato složka je navržena tak, aby obsahovala každou aplikaci, kterou vytvoříme. Prvním z nich bude web pro správu. Chcete-li to provést, proveďte následující příkaz:

$> mix phx.new admin --app admin - no-ecto

Volba --app [name] nám umožňuje definovat název aplikace OTP, což je runtime systém Erlang (aby se definice zjednodušila: je to nezávislá aplikace a zároveň plná knihovna).

Možnost --no-ecto odebere kroky k vytvoření souborů Ecto, což je způsob interakce s naší databází PostgreSQL.

Pokud bychom chtěli konkrétní název pro hlavní modul, mohli bychom použít volbu --module. Protože jej nepoužíváme, modul vezme název složky (zde: admin).

Poznámka: modul vždy začíná velkým písmenem.

Průzkum vytvořených aplikací pokračuji v dalším průvodci. Jediná změna, kterou provedeme v této části, bude v jednotlivých konfiguračních souborech po nastavení ukotvitelného panelu.

Když vložíme volbu --no-ecto, musíme vytvořit aplikaci, která bude pracovat s databází:

$> mix new database --app database --sup

Zde nebudujeme aplikaci Phoenix, ale pouze normální aplikaci Elixir, se stromem dohledu díky možnosti --sup. Tato volba je jakousi automaticky prováděna v aplikaci Phoenix, protože je pro ni povinná.

Zde je příkaz k vytvoření aplikace API:

$> mix phx.new api --app api --no-webpack --no-html --no-ecto

Volba --no-webpack odebere kroky k vytvoření základny CSS a JavaScript. Protože děláme API, nepotřebujeme žádné z nich.

Volba --no-html zruší krok vytváření šablon.

Poznámka: Během příštího průvodce porovnáme databázi a správce a správce a rozhraní API v části „Vytvořit rozhraní API“.

Vytvořme dvě poslední aplikace:

$> mix new agregator --app agregator --sup
$> mix phx.new webhook --app webhook --no-webpack --no-html --no-ecto

Odděluji API, agregátor a webhook aplikaci, protože chci, aby fungovaly samostatně. Protože každá aplikace může být nezávislá, můžete chtít zastavit API, ale ne agregátor nebo webhook, pokud dojde například k narušení zabezpečení.

Účelem agregátoru bude získávat příspěvky z vašeho zpravodajského kanálu Twitter a webový server bude zde, aby odesílal data lidem připojeným k vaší aplikaci. Protože agregátor by neměl být volán (ale měl by volat), nepotřebujeme zde Phoenix. Použijeme Poison ke zpracování HTTP volání, ale uvidíme to v příslušné části.

Jsme hotovi! Ale než půjdeme do Dockeru, musíme přidat jeden řádek do jednoho souboru:

  • V části apps / admin / asset / package.json přidejte v části skripty "build": "webpack --mode vývoj". V opačném případě se některým problémům vyhnete.

Pojďme se zabývat Dockerem

Když se vytvoří deštníkový projekt a dílčí projekty, můžeme se zaměřit na Dockera. K tomu je třeba vytvořit tři soubory:

  • Dockerfile
  • docker-compose.yml
  • .env

Dockerfile vytvoří obrázek ukotvení, který se používá v kontejneru, přičemž sám je:

Lehký, samostatný spustitelný balíček softwaru, který obsahuje vše potřebné k jeho spuštění: kód, runtime, systémové nástroje, systémové knihovny, nastavení.

Chcete-li vytvořit soubor Dockerfile, otevřete IDE do kořenového adresáře aplikace deštníku a přidejte soubor s názvem Dockerfile. Bude obsahovat seznam příkazů. Tento seznam bude proveden jednou plně, každý příkaz v samostatném dočasném kontejneru. A tak vytvořit celý obraz, po kterém budeme běžet.

Dále budeme pracovat na Docker-compose:

Docker-compose je nástroj pro definování a spouštění aplikací Docker pro více kontejnerů.

Soubor docker-compose bude definovat, který kontejner bude použit. Definuje také některé konfigurace a proměnné env. Soubor docker-compose musí být vytvořen v kořenovém adresáři a nazván docker-compose.yml. Jakmile je vytvořen, vložte následující kód dovnitř:

Protože máme proměnnou prostředí, musíme si vytvořit .env:

Dobrou praxí je přidat .env do .gitignore a vytvořit .env.dist ke sdílení struktury bez sdílení dat, která do ní vložíte (ochrana hesla, klíče API atd.).

Po vytvoření souborů docker-compose.yml a .env musíme vytvořit obrázek docker:

$> docker-compose build

Jakmile je sestavení dokončeno, vyzkoušejte naše docker-compose:

$> docker-compose up

Možná budete muset sdílet místní úložiště nebo provést nějakou konkrétní konfiguraci pro ukotvitelnou stanici. Můžete také zaznamenat vypnutí serveru elixir a pokud ne, pravděpodobně budete mít chybové zprávy. To je normální, protože jsme nic nenakonfigurovali, ai když to funguje, ještě není připraveno.

Zabijte tento proces pomocí ctlr + c a poté spusťte Postgres a Redis v tichém režimu pomocí následujícího příkazu:

$> docker-compose up -d postgres redis

Budou běžet jako úkoly na pozadí, takže se o ně nebudeme muset starat a jejich protokoly nás nebudou rušit.

Nyní získáme IP kontejneru Postgres, abychom jej mohli použít v našich konfiguračních souborech. Chcete-li to provést, zadejte:

$> docker ps
$> docker check -f '{{range.NetworkSettings.Networks}} {{. IPAddress}} {{end}}' [postgres_container_id]

docker ps zobrazí seznam spuštěných kontejnerů. S ID kontejneru Postgres použijte druhý příkaz k extrahování IP a jeho uložení pro pozdější použití.

Prohlídka doku nám umožňuje získávat data o konkrétním kontejneru. Předaná volba nám umožňuje získat pouze IP kontejneru, který použijeme v našem souboru .env. Nahraďte hodnotu PSQL_HOST výsledkem, který získáte z tohoto posledního příkazu.

Poznámka: vždy zahajte první a znovu druhou, protože IP je určeno příkazem ke spuštění.

Pro zjednodušení našeho života vytvoříme databázi ručně pomocí důležitého příkazu: docker-compose exec. Chcete-li to provést, zadejte:

$> docker-compose exec postgres psql user user

docker-compose exec provede příkaz v konkrétním kontejneru (zde je v postgrescontaineru).

psql, což je příkaz, je prostředí Postgresu a potřebuje k připojení databázi a roli (zde uživatel a uživatel). Chcete-li vytvořit dev a testovací databázi, zadejte následující příkaz:

VYTVOŘIT DATABÁZE test_dev;
VYTVOŘIT DATABÁZE test_test;

Chcete-li zkontrolovat, zda je databáze vytvořena, zadejte \ l a stiskněte enter. Na konci seznamu byste měli vidět dvě databáze.

Chcete-li opustit PSQL, stačí zadat \ q a stisknout enter. Nakonec můžete zastavit všechny kontejnery:

$> docker-compose stop

Konfigurace aplikací

Nyní, když máme vytvořených 5 aplikací a funkční dokovací stanici, udělejme trochu konfiguraci, nejprve ve 4 fénixových aplikacích:

  • V každé vytvořené aplikaci, ale databázi, otevřete soubor config / devs.exs a config / test.exs
  • V dev.exech změňte port na 4001, 4002, 4003 a 4004 (1 port na aplikaci)
  • V test.exs změňte port na 4101, 4102, 4103 a 4104 (1 port na aplikaci)

To je pro aplikace Phoenix. Musíme však také nakonfigurovat databázovou aplikaci. Každá změna zde bude provedena v aplikacích / databázi:

  • Vytvořte konfigurační složku. Uvnitř vytvořte 5 souborů: config.exs, dev.exs, prod.exs, prod.secret.exs a test.exs
  • Do každého souboru přidejte na začátku použití Mix.Config
  • Do souboru config.exs přidejte následující řádky:
config: database,
  ecto_repos: [Database.Repo]
import_config "# {Mix.env ()}. exs"
  • Do prod.exs přidejte následující řádek: import_config „prod.secret.exs“
  • V každém dalším souboru přidejte (pozor na 2 poslední řádky):
config: database, Database.Repo,
  uživatelské jméno: System.get_env („POSTGRES_USER“),
  heslo: System.get_env ("POSTGRES_PASSWORD"),
  database: System.get_env ("POSTGRES_DB_ENV"), # nahradit env dev, otestovat nebo odstranit v závislosti na souboru
  název hostitele: System.get_env ("POSTGRES_HOST"),
  pool_size: 10 # v dev.exs et prod.secret.exs
  pool: Ecto.Adapters.SQL.Sandbox # v test.exs

Nakonec přidáme Ecto do aplikace Database:

  • Otevřete databázi / mix.exs, v seznamu projektů přidejte aliasy: aliasy ().
  • Stále v databázi / mix.exs v seznamu deps přidejte {: ecto_sql, "~> 3.0"} a {: postgrex, "> = 0.0.0"}.
  • V databázi / mix.exs znovu přidejte funkci aliasy, jako například:
defp aliasy ano
  [
    “Ecto.setup”: [“ecto.create”, “ecto.migrate”, “run priv / repo / seeds.exs”],
    „Ecto.reset“: [„ecto.drop“, „ecto.setup“],
    test: [„ecto.create - tichý“, „ecto.migrate“, „test“]
  ]
konec
  • Nyní otevřete lib / database / application.ex a přidejte Database.Repo do seznamu dětí
  • Nakonec vytvořte lib / database / repo.ex a vložte dovnitř následující:
defmodule Database.Repo dělat
  použijte Ecto.Repo,
    otp_app:: database,
    adaptér: Ecto.Adapters.Postgres
konec

Nyní můžete dýchat, konfigurace a nastavení jsou u konce.

Po dokončení konfigurace zkuste znovu náš kontejner Elixir:

$> docker-compose up -d postgres
$> docker-compose up elixir

Přejděte do svého prohlížeče a zadejte localhost: 4001. Měli byste vidět něco jako tento obrázek, což znamená, že Phoenix a Docker jsou dobře nakonfigurované:

Nechte přidat dotek gitového submodulu

Nyní, když máme připravený náš projekt, vytvořme úložiště git pro zastřešující aplikaci.

Důležité: protože deštník obsahuje další projekty, zatím nepřidávejte, nezavazujte a nic netlačte. Stačí propojit váš projekt s úložištěm git (git init a git remote add origin).

Protože je tato příručka určena lidem s určitými zkušenostmi s git, očekávám, že budete vědět, jak to udělat. Pokud ne, postupujte podle těchto pokynů:

  • Pokud vytvoříte projekt s otevřeným zdrojovým kódem: Github
  • Pokud chcete soukromé repo: Gitlab

V případě, že vytvoříte projekt Github s otevřeným zdrojovým kódem, nepřidávejte během vytváření projektu gitignore .gitignore. Stále můžete vytvořit soubor LICENSE. Pokud tak učiníte, budete muset před tlačením udělat:

$> git pull # by to mělo selhat, ale umožní vám přístup k masterovi
$> git --set-upstream-to = původ / hlavní master
$> git pull --allow-nesúvisící-historie

Po vytvoření a přidání projektu do úložiště se přesuneme do složky aplikací.

$> cd ./apps

Git subodule

Vytvořte nový projekt v gitu pro každou aplikaci se stejným názvem jako složka aplikace. Opět je to nesmírně důležité, abychom se vyhnuli nutnosti provádět mnohem více konfigurace, než je nutné.

Propojte každou aplikaci s přidruženým úložištěm git a posuňte je. Po dokončení přejděte zpět do složky aplikací. Odtud stačí zadat 5krát stejný příkaz:

$> git submodules add [repository_url]

Po dokončení prvního příkazu bude vytvořen nový soubor: .gitmodule. Obsahuje seznam všech použitých submodulů.

Slovo o submodulech: měli byste být schopni je aktualizovat v kořenovém adresáři projektu pomocí jednoduchého git pull. Ale stejně jako já, možná budete muset také stáhnout jednotlivé aplikace. Pravděpodobně nejsem tak dobrý, jak byste mohli být s nimi.

Myšlenkou použití dílčích modulů je umožnit ostatním lidem přístup pouze k vybraným aplikacím, ke kterým chcete, ale také k odlišení kterékoli z vašich aplikací, protože nemusí potřebovat, aby fungovaly jiné aplikace. Díky tomu budete moci sledovat oddělenou evoluci (bez všech větví) atd.

Důležité: Nyní můžete přidat vše do úložiště git deštníkové aplikace, odevzdat a tlačit.

Tuto příručku dokončíme dvěma nepovinnými příkazy:

$> mix deps.get

Které stahují potřebné Elixirovy závislosti.

$> cd apps / admin / asset
$> npm instalace
$> npm run build

Stáhněte si závislosti JS a zkompilujte je (a CSS) do / priv / static. Upozornění: Tímto způsobem můžete přepsat statický obsah v kontejneru ukotvitelného panelu, protože jsme cestu této složky nevložili do ukotvitelného dokladu.

To je pro dnešek vše! Doufám, že vás tento druhý kurz potěšil a pomohl vám založit zastřešující projekt Elixir.

Další průvodce, vytvoříme uživatelskou část administračního webu a přidáme na něj nějaký bootstrap.

Až příště, šťastné kódování!

Upravit 18/03/2019:

  • Změnit všechny soubory doku (včetně rady Eduarda Liberumena ohledně nastavení env)
  • Přidejte pátou aplikaci, která zvládne veškerou interakci s databází, více v souladu s myšlenkou narušení zabezpečení API (s počáteční myšlenkou by zastavení API způsobovalo chyby v jiných aplikacích, protože to bylo API, které mělo zpracovat data)
  • Odstraňte Ecto ze čtyř prvních aplikací
  • Přidejte nastavení Ecto do páté aplikace, protože nejde o aplikaci Phoenix

Trvalo mi nějaký čas, než jsem se vrátil ke psaní, a omlouvám se za to každému, kdo se chtěl pomocí tohoto průvodce dozvědět více o zastřešujícím projektu. Život se právě stal.

Upravit 19/03/2019: do části git přidejte několik podrobností

Upravit 20/03/2019: přidat řádek do Dockerfile RUN apt-get install -y inotify-tools

Upravit 03/08/2019: aktualizace na Elixir 1.9

Upravit 17/09/2019: změnit Agregátor z aplikace Phoenix na normální aplikaci.