Хлопки — это новая функция в экосистеме NIX. Хлопки заменяют государственные каналы (которые вызывают большую путаницу между новичками) и вводят более интуитивно понятный и последовательный интерфейс CLI, что дает им прекрасную возможность начать использовать NIX.
Этот пост является быстрым введением в саму NIX, а функция хлопьев специально. Он содержит примеры и советы по использованию хлопьев для реального варианта использования: создание приложений на различных языках.
Что такое NIX?
Кратко, NIX — это менеджер пакетов и система сборки. Его наиболее важным аспектом является писать декларативные сценарии для воспроизводимых сборки программного обеспечения. Это также помогает тестировать и развернуть программные системы при использовании парадигмы функционального программирования. Существует обширное хранилище пакетов для NIX, называемого nixpkgs и распределение GNU/Linux, которое расширяет идеи NIX на уровень ОС, называемый Никсос Анкет
Инструкции по строительству NIX называются «Деривациями» и написаны на языке программирования. Деривации могут быть написаны для пакетов или даже целых систем. После этого они могут быть детерминированно «реализованы» (построены) через NIX, менеджер пакетов. Деривации могут зависеть только от предварительно определенного набора входов, поэтому они несколько воспроизводимы.
Вы можете прочитать больше о преимуществах NIX в моем блоге на nix Анкет
Что такое хлопья Nix?
Хлопки-это автономные единицы, которые имеют входные данные (зависимости) и выходы (пакеты, инструкции по развертыванию, функции NIX для использования в других хлопьях). Вы можете думать о них как о ящиках ржавчины или модулями GO, но независимым от языка. Хлопки имеют большую воспроизводимость, потому что им разрешено зависеть только от их входов, и они прикрепляют точные версии указанных входов в файл блокировки.
Если вы уже знакомы с NIX, хлопья должны высказывать выражения, какие производные для создания инструкций.
Начало работы с NIX
Чтобы сделать что -либо с хлопьями, вам сначала нужно будет получить «нестабильный», но и запустить на вашем машине. Не возражайте, что это называется нестабильным: в целом не опасно работать на вашей машине, он просто меняется чаще, чем «стабильный». Самый простой способ — использовать официальный установщик, который будет работать на любой подсистеме Linux Distro, MacOS или Windows для Linux:
curl -L https://nixos.org/nix/install | sh
Следуйте инструкциям, пока у вас не будет работать над вашей машиной, а затем обновите, что нестабильно с:
nix-env -f '' -iA nixUnstable
И включить экспериментальные особенности с:
mkdir -p ~/.config/nix echo 'experimental-features = nix-command flakes' >> ~/.config/nix/nix.conf
Если вы используете Nixos или у вас есть проблемы с установкой, обратитесь к Wiki Nixos: https://nixos.wiki/wiki/flakes#installing_flakes
Почувствовать хлопья
Теперь, когда у вас установлен «слоистый» NIX, пришло время использовать его!
Nix Shell
Во -первых, давайте введем оболочку с GNU Hello из филиала Nixpkgs ‘ nixpkgs-unstable в этом:
nix shell github:nixos/nixpkgs/nixpkgs-unstable#hello
Обратите внимание, что это начнет ту же оболочку, что и вы, но добавьте каталог, содержащий привет исполняемый для вашего $ Path . Оболочка не должна выглядеть иначе, чем она была за пределами Nix Shell , так что не паникуйте, если похоже, что ничего не происходит! Исполняемый файл не установлен нигде как таковой, он загружается и распаковывается в том, что вы можете рассмотреть каталог кэша.
Теперь, внутри этой оболочки, попробуйте бежать Привет Анкет
Давайте рассмотрим, что делает эта команда. Nix Shell это подкоманда NIX, которая используется для запуска оболочки с некоторыми пакетами, доступными в $ Path Анкет Эти пакеты могут быть указаны в качестве аргументов в формате «Установка». Каждая установка содержит две части: URL ( github: nixos/nixpkgs/master в этом случае) и «путь атрибута» ( Привет здесь).
Поддерживается несколько схем URL:
GitHub: владелец/репо/[Revision или Branch]иgitlab: владелец/репо/[Revision или Branch](Для публичных хранилищ на github.com и gitlab.com ; обратите внимание, что имя филиала не может содержать ударов).https://example.com/path/to/tarball.tar.gzдля тарболов.git+https://example.com/path/to/repo.gitиgit+ssh://example.com/path/to/repo.gitДля простых репозиториев GIT (вы, конечно, можете использовать это для GitHub и Gitlab). Вы можете указать ветвь или ревизию, добавив? ref = <Имя ветви здесь>АнкетФайл:///path/to/каталогили/path/to/Directoryили./path/to/relative/directoryдля местного каталога.Запись о регистрацииЗа ценность из реестра хлопьев (я не буду говорить о регистрах Flake в этой статье).
Итак, есть другие способы получить ту же оболочку:
nix shell https://github.com/nixos/nixpkgs/archive/nixpkgs-unstable.tar.gz#hello nix shell 'git+https://github.com/nixos/nixpkgs?ref=nixpkgs-unstable#hello' nix shell nixpkgs#hello # nixpkgs is specified in the default registry to be github:nixos/nixpkgs
Что касается пути атрибута, то на данный момент просто знайте, что это разделенный на период список Nix «имен атрибутов», который выбирает вывод хлопья в соответствии с какой-то простой логикой.
Обратите внимание, что в этом случае NIX не нужно было ничего строить, так как он мог просто получить GNU Hello и его зависимости от бинарного кеша. Чтобы достичь этого, NIX оценивает Деривация Из выражения, хэши его содержимое и запрашивает все кэши, которые он знает, чтобы увидеть, есть ли у кого -то вывод с этим хэш -кэшированным. NIX использует все зависимости и все инструкции в качестве ввода для этого хэша! Если какой -то двоичный кеш имеет готовую версию, это может быть Заменил (скачано). В противном случае, NIX построит вывод, сначала реализуя (заменив или построение) все зависимости, а затем выполняя инструкции по сборке.
Вам может быть интересно, где именно установлен исполняемый файл. Ну, попробуй командование -v Привет Чтобы увидеть, что он расположен в подкаталоге /nix/магазин . На самом деле, все nix Деривации Иметь «пути хранения» (пути, расположенные в /nix/store ) в качестве входов и выходов.
NIX BUILD
Если вы просто хотите что -то построить вместо того, чтобы войти в оболочку с ней, попробуйте nix build :
$ nix build nixpkgs#hello
Это построит привет (или принесет его из двоичного кеша, если будет доступно), а затем сослать его к результат в вашем текущем каталоге. Затем вы можете исследовать результат Например,
$ ./result/bin/hello Hello, world!
nix развивается
Несмотря на использование двоичных кэшей, NIX является менеджером пакетов, первого SourceCode. Это означает, что он способен обеспечить среду сборки для своих дериваций. Таким образом, вы можете использовать NIX для управления вашими средами сборки для вас! Чтобы войти в оболочку со всеми зависимостями времени выполнения и строительства GNU Hello, используйте:
$ nix develop nixpkgs#hello
Внутри этой оболочки вы можете позвонить Unpackphase поместить GNU Привет источники в текущем каталоге, затем ConfigurePhase запустить Настройка Скрипт с правильными аргументами и, наконец, BUILDPHASE строить.
nix profile
NIX реализует государственные «профили», чтобы пользователи могли «постоянно» устанавливать вещи.
Например:
nix profile install nixpkgs#hello nix profile list nix profile update hello nix profile remove hello
Если вы уже знакомы с NIX, это замена для nix-env Анкет
Никс Флеки
Никс Флейк Набор подкомандов используется для наблюдения и манипулирования самими хлопьями, а не их результатами.
NIX Flake Show
Эта команда принимает чешуйчатую URI и печатает все выходы чешуйки как хорошую структуру дерева, отображая пути атрибутов на типы значений.
Например:
$ nix flake show github:nixos/nixpkgs
github:nixos/nixpkgs/d1183f3dc44b9ee5134fcbcd45555c48aa678e93
├───checks
│ └───x86_64-linux
│ └───tarball: derivation 'nixpkgs-tarball-21.05pre20210407.d1183f3'
├───htmlDocs: unknown
├───legacyPackages
│ ├───aarch64-linux: omitted (use '--legacy' to show)
│ ├───armv6l-linux: omitted (use '--legacy' to show)
│ ├───armv7l-linux: omitted (use '--legacy' to show)
│ ├───i686-linux: omitted (use '--legacy' to show)
│ ├───x86_64-darwin: omitted (use '--legacy' to show)
│ └───x86_64-linux: omitted (use '--legacy' to show)
├───lib: unknown
└───nixosModules
└───notDetected: NixOS module
Никс Флеки Клон
Nix Flake Clone Будет клонировать источник хлопья в локальный каталог, аналогично git клон .
Давайте клонируем какую -то простую чешуйку и используем какую -то другую Никс Флейк подкоманды на нем:
nix flake clone git+https://github.com/balsoft/hello-flake/ -f hello-flake cd hello-flake
Nix Flake Lock (ранее Nix Flake Update)
Каждый раз, когда вы называете команду NIX на какую -то хлопья в локальном каталоге, NIX позаботится о том, чтобы содержимое Flake.lock удовлетворить Вход в Flake.nix . Если вы хотите сделать это, не на самом деле не построив (или даже оценивая) какие -либо выходы, используйте Nix Flake Lock Анкет
Есть также некоторые аргументы в пользу манипуляции с хлопьями, которые могут быть переданы большинству команд NIX:
-Включение вводапринимает имя ввода, которое вы указали вВходизFlake.nixи чешуйчатый URI, чтобы обеспечить в качестве этого ввода; —-Попдат-входПримет имя ввода и обновите этот ввод в последнюю версию, удовлетворяющую Flake URI изFlake.nix.
Написал свой собственный
Теперь, когда вы знаете, как взаимодействовать с хлопьями, пришло время написать его.
Nix Language Represher
Широко используемый тип данных в NIX-это набор атрибутов: тип данных для хранения пар клавиш. Это похоже на объект JSON или HashMap на многих языках. Его синтаксис сбивающий с толку похож на список утверждений на C-подобных языках:
{
hello = "world";
foo = "bar";
}
Набор выше эквивалентен этому объекту JSON:
{
"hello": "world",
"foo": "bar"
}
Привет и бар обычно называют «атрибутами» или «именами атрибутов»; "Мир" и "Бар" являются «значениями атрибутов».
Чтобы получить значение атрибута из набора атрибутов, используйте Анкет . Например:
let
my_attrset = { foo = "bar"; };
in my_attrset.foo
( пусть ... в — это способ создания привязки; синтаксис внутри него идентичен синтри -набору атрибутов)
Вы также можете сократить свой набор атрибутов, установив определенные атрибуты с Анкет вместо определения всего набора:
{
foo.bar = "baz";
}
Эквивалентно
{
foo = { bar = "baz"; };
}
Другие типы включают строки ( "foo" ), числа (1, 3.1415), гетерогенные списки ( [1 2 "foo"] ) и — совершенно важно — функции ( x: x + 1 ).
Функции Поддержки поддержания шаблона на наборах атрибутов. Например, эта функция:
{ a, b }: a + b
Когда вызываются с {;; } вернется 30.
Функциональное приложение выполнено в стиле ML:
let
f = { a, b }: a + b;
in f { a = 10; b = 20; }
Сама функция приходит на первое место. Тогда есть отдельный список аргументов.
Если вы хотите иметь функцию нескольких аргументов, используйте карри:
let f = a: b: a + b; in f 10 20
В этом примере F 10 оценивается на B: 10 + B В а затем F 10 20 оценивается на 30 Анкет
Если вы хотите узнать больше о NIX, проверьте Соответствующий ручной раздел и Nix таблетки Анкет
Основная структура хлопья
Описание языка, которое вы получили выше, далеки от полного или формального, но оно должно помочь вам понять и, что более важно, написать несколько простых выражений NIX и, что еще более важно, чешуйка.
Nix Flake — это каталог, который содержит Flake.nix файл. Этот файл должен содержать набор атрибутов с одним необходимым атрибутом — выходы — и необязательно Описание и Вход Анкет
выходы это функция, которая принимает набор атрибутов входов (всегда есть хотя бы один вход — self — который относится к чешуйке, которую в настоящее время оценивает NIX; это возможно из -за лени). Итак, наиболее тривиальная чешуйка — это:
{
outputs = { self }: { };
}
Это чешуйчака без внешних входов и выходных данных. Не очень полезно, а?
Ну, мы можем добавить к нему произвольный выход и оценить его с помощью nix eval Чтобы увидеть, что это работает:
{
outputs = { self }: {
foo = "bar";
};
}
$ nix eval .#foo
"bar"
Все еще не очень полезен, хотя.
Давайте сделаем чешуйку, которая делает что -то полезное! Для этого нам, скорее всего, понадобятся некоторые входные данные:
{
inputs = {
nixpkgs.url = "github:nixos/nixpkgs";
};
outputs = { self, nixpkgs }: { };
}
Все еще не очень полезен; У нас нет результатов! Однако теперь есть внешний nixpkgs вход.
В то время как атрибут устанавливает это выходы Возвраты могут содержать произвольные атрибуты, некоторые стандартные выходы понимаются по различным nix коммунальные услуги. Например, есть пакеты Вывод, который содержит пакеты. Он хорошо работает с командами, описанными в Почувствуя хлопья Анкет Давайте добавим это!
{
inputs = {
nixpkgs.url = "github:nixos/nixpkgs";
};
outputs = { self, nixpkgs }: {
packages.x86_64-linux.hello = /* something here */;
};
}
Прежде всего, давайте поймем, зачем нам нужно x86_64-linux здесь. Flakes обещают нам Герметическая оценка что означает, что выходы чешуйки должны быть одинаковыми независимо от среды оценщика. Одним из конкретных свойств оценки среды, которая очень актуальна в системе сборки, является Платформа (комбинация архитектуры и ОС). Из -за этого все выходы хлопья, которые имеют какое -либо отношение к пакетам, должны каким -то образом указать платформу. Стандартный способ состоит в том, чтобы вывод был набором атрибутов с именами, являющимися платформами, а значения — это то, что выходной семантически представляет, но построен специально для этой платформы. В случае Пакеты Каждое значение для платформы представляет собой набор атрибутов пакетов.
Теперь вы можете подумать: ну, как мы можем просто написать nix build nixpkgs#hello И получить пакет без четкого указания платформы? Ну, это потому, что Никс на самом деле делает это для вас за кулисами. Для Nix Shell , nix build В nix profile , а также nix развивать (Среди некоторых других команд) Никс пытается выяснить, какой вывод вы хотите, попробовав несколько в определенном порядке. Допустим, вы делаете nix build nixpkgs#hello На машине x86_64 под управлением Linux. Тогда Никс попытается:
приветPackages.x86_64-linux.helloLegacypackages.x86_64-linux.hello
Мы уже знакомы с Пакеты выход; Legacypackages разработан специально для NixPKGS. Репозиторий Nixpkgs намного старше хлопья, поэтому его произвольный формат атрибута невозможно в аккуратный Пакеты Анкет Legacypackages был разработан, чтобы приспособиться к устаревшему беспорядку. В частности, Legacypackages Позволяет, чтобы наборы пакетов были произвольными наборами атрибутов, а не структурированными пакетами.
Итак, давайте повторно Привет от nixpkgs в нашей собственной чешуйке:
{
inputs = {
nixpkgs.url = "github:nixos/nixpkgs";
};
outputs = { self, nixpkgs }: {
packages.x86_64-linux.hello = nixpkgs.legacyPackages.x86_64-linux.hello;
};
}
Теперь мы можем построить пакет Reexported:
$ nix build .#hello
Или запустить это:
$ nix run .#hello Hello, world!
(По умолчанию, nix run выполнит двоичный файл с тем же именем, что и имя атрибута пакета.)
Ура! Теперь у нас есть хлопья, которая выводит пакет, который мы можем использовать или построить.
Еще одна вещь, которую мы можем добавить, — это «разработка» оболочка, содержащая некоторые утилиты, которые могут быть полезны при работе над нашей чешуйкой. В этом примере, возможно, мы хотим иметь Привет и Коусей в $ Path Чтобы распечатать дружеское приветствие, а затем заставить корову сказать это. Существует особый результат для таких оболочек разработки, называемых Devshell Анкет Существует также функция для построения таких снарядов в Nixpkgs. Чтобы предотвратить написание громоздкого nixpkgs.legacypackages.x86_64-linux Несколько раз давайте извлеките его через пусть ... в Переплет:
{
inputs = { nixpkgs.url = "github:nixos/nixpkgs"; };
outputs = { self, nixpkgs }:
let pkgs = nixpkgs.legacyPackages.x86_64-linux.hello;
in {
packages.x86_64-linux.hello = pkgs.hello;
devShell.x86_64-linux =
pkgs.mkShell { buildInputs = [self.packages.x86_64-linux.hello pkgs.cowsay]; };
};
}
Теперь мы можем войти в среду разработки с nix развивать Анкет Если вы хотите запустить оболочку, кроме Bash в этой среде, вы можете использовать nix shell -c $ shell Анкет
$ nix develop -c $SHELL
$ hello | cowsay
_______________
< Hello, world! >
---------------
\ ^__^
\ (oo)\ _______
(__)\ )\/\
||----w |
|| ||
Давайте рассмотрим нашу чешуйку, используя Nix Flake Show :
$ nix flake show
path:/path/to/flake
├───devShell
│ └───x86_64-linux: development environment 'nix-shell'
└───packages
└───x86_64-linux
└───hello: package 'hello-2.10'
Теперь, когда мы написали нашу немного полезную «Привет», время, чтобы перейти к практическим приложениям!
Некоторые советы и хитрости
Диренв
Вы можете использовать Direnv с nix-direnv автоматически ввести Devshell Когда вы меняете каталог в проект, который упакован в чешуйку. .envrc Файл действительно прост в этом случае:
use flake
чешуйчатые утилизации
Существует библиотека, которая помогает вам извлечь скучные платформенные аттроты: Flake-Utils Анкет Если в нашем примере мы используем утилизацию хлопьев, мы можем заставить его поддержать все платформы NixPKGS практически без дополнительного кода:
{
inputs = {
nixpkgs.url = "github:nixos/nixpkgs";
flake-utils.url = "github:numtide/flake-utils";
};
outputs = { self, nixpkgs, flake-utils }:
flake-utils.lib.eachDefaultSystem (system:
let pkgs = nixpkgs.legacyPackages.${system};
in {
packages.hello = pkgs.hello;
devShell = pkgs.mkShell { buildInputs = [pkgs.hello pkgs.cowsay]; };
});
}
Обратите внимание, как теперь есть больше платформ на выводе Nix Flake Show :
path:/path/to/flake
├───devShell
│ ├───aarch64-linux: development environment 'nix-shell'
│ ├───i686-linux: development environment 'nix-shell'
│ ├───x86_64-darwin: development environment 'nix-shell'
│ └───x86_64-linux: development environment 'nix-shell'
└───packages
├───aarch64-linux
│ └───hello: package 'hello-2.10'
├───i686-linux
│ └───hello: package 'hello-2.10'
├───x86_64-darwin
│ └───hello: package 'hello-2.10'
└───x86_64-linux
└───hello: package 'hello-2.10'
Все атрибуты платформы автоматически вставляются с помощью утилизаторов.
Упаковка существующих приложений
Наиболее очевидным вариантом использования Flakes является упаковка существующих приложений, чтобы получить преимущества экосистемы NIX. Чтобы облегчить это, я написал библиотеку шаблонов, которые вы можете использовать с nix flake init -t . Этот раздел будет в основном о настройке шаблонов для правильного построения вашего приложения.
Haskell (Cabal)
Хаскелл имеет распространенное присутствие в экосистеме NIX. Nixpkgs содержит полное зеркало взлома, и существует несколько инструментов, которые облегчают создание приложений Haskell с использованием NIX.
Самый популярный способ построения приложений Haskell с NIX — Cabal2nix . Он извлекает информацию о зависимости из файла CABAL вашего проекта и использует NIXPKGS HaskellPackages Сбор для разрешения этих зависимостей.
Чтобы добавить его в существующее приложение Haskell, Do:
nix flake init -t github:serokell/templates#haskell-cabal2nix
Это создаст Flake.nix Похоже на это (обратите внимание на throw <... > замена для имени; Напишите название своего проекта там).
{
description = "My haskell application";
inputs = {
nixpkgs.url = "github:NixOS/nixpkgs";
flake-utils.url = "github:numtide/flake-utils";
};
outputs = { self, nixpkgs, flake-utils }:
flake-utils.lib.eachDefaultSystem (system:
let
pkgs = nixpkgs.legacyPackages.${system};
haskellPackages = pkgs.haskellPackages;
jailbreakUnbreak = pkg:
pkgs.haskell.lib.doJailbreak (pkg.overrideAttrs (_: { meta = { }; }));
packageName = throw "put your package name here!";
in {
packages.${packageName} = # (ref:haskell-package-def)
haskellPackages.callCabal2nix packageName self rec {
# Dependency overrides go here
};
defaultPackage = self.packages.${system}.${packageName};
devShell = pkgs.mkShell {
buildInputs = with haskellPackages; [
haskell-language-server
ghcid
cabal-install
];
inputsFrom = builtins.attrValues self.packages.${system};
};
});
}
Используя чешуйку
Вы можете построить DefaultPackage используя nix build и делайте все остальные обычные вещи: Nix Shell , nix развивать , так далее.
Потенциальные модификации и устранение неполадок
Если вам не нужны некоторые инструменты разработки, представленные в Devshell (например, языковой сервер или GHCID), просто удалите их.
Если вам нужна другая версия GHC, выберите его в Haskellpackages Определение, например, для использования GHC 9.0.1, DO:
haskellPackages = pkgs.haskell.packages.ghc901;
В случае, если какая -то зависимость не может построить, вам необходимо переопределить ее в определении пакета (последний аргумент callcabal2nix , точный). Например, если ваш проект зависит от Gi-GTK-деколаративно и он сломан в текущей версии Nixpkgs, потому что некоторые ограничения версий не совпадают, DO (заменить имя пакета сбоя для Gi-GTK-деколаративность ):
# <...>
packages.${packageName} =
haskellPackages.callCabal2nix packageName self rec {
gi-gtk-declarative =
jailbreakUnbreak haskellPackages.gi-gtk-declarative;
};
# <...>
Примечание: Jailbreakunbreak Только удаляет ограничения версии CABAL. Если в какой -то зависимости существует фактическое нарушение изменения, сборка все равно потерпит неудачу. В этом случае вы мало что можете сделать, кроме как попытаться решить фактическую проблему с помощью пакета, которая требует некоторого понимания того, как overdeattrs Работает, и это не так. Не бойтесь читать руководство Nixpkgs или просить о помощи в любом из сообществ Nix, которые вы можете найти!
Если какая -то зависимость не может построить из -за неудачных тестов (что может быть так, когда тесты требуют доступа к сети или локального ресурса, недоступного от сборки NIX), вы можете отключить их так:
# <...>
packages.${packageName} =
haskellPackages.callCabal2nix packageName self rec {
gi-gtk-declarative =
pkgs.haskell.lib.dontCheck haskellPackages.gi-gtk-declarative;
};
# <...>
Другие варианты сборки
Некоторые другие варианты создания приложений и библиотек Haskell с NIX:
Ржавчина (груз)
Rust также довольно популярна в сообществе NIX, хотя из -за относительно молодого возраста интеграция не так хороша в это время. Есть несколько конкурирующих способов построения ящиков. Я предпочитаю путь Crate2nix Работы: это очень похоже на операцию на Cabal2nix, но это немного сложнее из -за некоторых особенностей груза.
Чтобы получить шаблон, который строит один грузовой ящик через Crate2nix, запустите nix flake init -t github: serokell/templates#rust -crate2nix Анкет Flake.nix будет похож на этот файл:
{
inputs = {
nixpkgs.url = "github:nixos/nixpkgs";
crate2nix = {
url = "github:kolloch/crate2nix";
flake = false;
};
flake-utils.url = "github:numtide/flake-utils";
};
outputs = { self, nixpkgs, crate2nix, flake-utils }:
flake-utils.lib.eachDefaultSystem (system:
let
pkgs = nixpkgs.legacyPackages.${system};
crateName = throw "Put your crate name here";
inherit (import "${crate2nix}/tools.nix" { inherit pkgs; })
generatedCargoNix;
project = pkgs.callPackage (generatedCargoNix {
name = crateName;
src = ./.;
}) {
defaultCrateOverrides = pkgs.defaultCrateOverrides // {
# Crate dependency overrides go here
};
};
in {
packages.${crateName} = project.rootCrate.build;
defaultPackage = self.packages.${system}.${crateName};
devShell = pkgs.mkShell {
inputsFrom = builtins.attrValues self.packages.${system};
buildInputs = [pkgs.cargo pkgs.rust-analyzer pkgs.clippy];
};
});
}
Устранение неполадок и улучшения
Предположим, что ваш пакет требует некоторых «нативных» (без роста) библиотек, либо сам, либо транзисивно через зависимость. В этом случае вы должны указать их вручную на DefaultCrateOverrides , если они уже не указаны в Nixpkgs ‘ DefaultCrateOverrides Анкет Например, если ваше приложение называлось мой музыкант-игрок Требуется LibpulseAudio В
# <...>
defaultCrateOverrides = pkgs.defaultCrateOverrides // {
my-music-player = _: {
buildInputs = [pkgs.libpulseaudio];
};
}
#<...>
Альтернативы
- Вручную с использованием
BuildRustcrateот nixpkgs - Наерск
Python (поэзия)
Экосистема Python несколько поддерживается в Nixpkgs через Python3packages , но поддержка не такая полная, как для Хаскелла. Однако, если ваш проект упакован с поэзией, вам повезло, так как есть Поэзия2nix что позволяет легко создавать приложение.
Инициализировать шаблон, nix flake init -t github: serokell/templates#python -poetry2nix . Это выглядит примерно так:
{
description = "My Python application";
inputs = {
nixpkgs.url = "github:NixOS/nixpkgs";
flake-utils.url = "github:numtide/flake-utils";
};
outputs = { self, nixpkgs, flake-utils }:
flake-utils.lib.eachDefaultSystem (system:
let
pkgs = nixpkgs.legacyPackages.${system};
customOverrides = self: super: {
# Overrides go here
};
app = pkgs.poetry2nix.mkPoetryApplication {
projectDir = ./.;
overrides =
[pkgs.poetry2nix.defaultPoetryOverrides customOverrides];
};
packageName = throw "put your package name here";
in {
packages.${packageName} = app;
defaultPackage = self.packages.${system}.${packageName};
devShell = pkgs.mkShell {
buildInputs = with pkgs; [poetry];
inputsFrom = builtins.attrValues self.packages.${system};
};
});
}
Исправление проблем
В случае, если какая -то зависимость не может построить, вам нужно исправить ее, переопределив ее в CustomOverrides Анкет Смотрите https://github.com/nix-community/poetry2nix/blob/master/overrides.nix Для различных примеров переопределения.
Следующий
В предстоящей статье я объясню, как использовать хлопья для создания и запуска контейнеров и настройки развертывания инфраструктуры. Чтобы убедиться, что вы слышите об этом, вы можете следить за Серокеллом на Twitter Анкет Следите за обновлениями!
Оригинал: «https://dev.to/serokell/practical-nix-flakes-5e6p»