Zum Inhalt springen
1337skills 1337skills - Referenzen

Mix

Mix is Elixir’s build tool that provides project scaffolding, dependency management, compilation, testing, and deployment capabilities.

Installation

# Install Erlang and Elixir
# macOS with Homebrew
brew install erlang elixir

# Ubuntu/Debian
sudo apt-get install erlang elixir

# Verify installation
mix --version
elixir --version

Creating Projects

New Project

# Create new Mix project
mix new my_app

# Create umbrella project (monorepo)
mix new --umbrella my_umbrella

# Create with supervisor
mix new my_app --sup

# Check project structure
tree my_app

Project Structure

my_app/
├── _build/              (Compiled output)
├── lib/                 (Application code)
│   └── my_app.ex
├── test/                (Tests)
│   └── my_app_test.exs
├── mix.exs              (Project manifest)
├── mix.lock             (Dependency lock file)
└── README.md

Project Configuration

mix.exs

defmodule MyApp.MixProject do
  use Mix.Project

  def project do
    [
      app: :my_app,
      version: "0.1.0",
      elixir: "~> 1.14",
      start_permanent: Mix.env() == :prod,
      deps: deps()
    ]
  end

  def application do
    [
      extra_applications: [:logger],
      mod: {MyApp.Application, []}
    ]
  end

  defp deps do
    [
      {:plug_cowboy, "~> 2.6"},
      {:ecto_sql, "~> 3.10"},
      {:postgrex, ">= 0.0.0"},
      {:jason, "~> 1.2"},
      {:ex_doc, "~> 0.30", only: :dev, runtime: false},
      {:dialyxir, "~> 1.4", only: :dev, runtime: false}
    ]
  end
end

Essential Commands

CommandDescription
mix compileCompile project
mix deps.getInstall dependencies
mix deps.updateUpdate dependencies
mix testRun tests
mix runExecute project
mix ecto.setupSetup database
mix formatFormat code
mix credoLint code

Dependency Management

# Get dependencies
mix deps.get

# Update dependencies
mix deps.update

# Update specific dependency
mix deps.update plug_cowboy

# Remove dependency
# Edit mix.exs and run mix deps.clean

# Show dependency tree
mix deps.tree

# Check if dependencies are available
mix deps

Building & Compilation

# Compile project
mix compile

# Compile with warnings as errors
mix compile --warnings-as-errors

# Clean compiled output
mix clean

# Recompile everything
mix clean && mix compile

# Run with interactive shell
iex -S mix

# Run specific module
mix run -e "MyApp.main()"

Testing

Running Tests

# Run all tests
mix test

# Run tests for specific file
mix test test/my_app_test.exs

# Run specific test
mix test test/my_app_test.exs:12

# Run with coverage
mix test --cover

# Run tests matching pattern
mix test --only integration

# Verbose output
mix test --verbose

Test Structure

defmodule MyAppTest do
  use ExUnit.Case
  doctest MyApp

  setup do
    # Setup code
    :ok
  end

  test "greets the world" do
    assert MyApp.hello() == :world
  end

  @tag :integration
  test "integration test" do
    # Integration test
    assert true
  end
end

Database Management

Ecto Setup

# Create database
mix ecto.create

# Run migrations
mix ecto.migrate

# Rollback migrations
mix ecto.rollback

# Reset database
mix ecto.drop && mix ecto.create && mix ecto.migrate

# Generate migration
mix ecto.gen.migration add_users_table

# Check migration status
mix ecto.migrations

migration example

defmodule MyApp.Repo.Migrations.CreateUsers do
  use Ecto.Migration

  def change do
    create table(:users) do
      add :email, :string, null: false
      add :name, :string
      timestamps()
    end

    create unique_index(:users, [:email])
  end
end

Phoenix Framework

Create Phoenix Project

# Install Phoenix generator
mix archive.install hex phx_new

# Create Phoenix project
mix phx.new my_app
cd my_app

# Install dependencies
mix deps.get

# Setup database
mix ecto.setup

# Start server
mix phx.server

Phoenix Generators

# Generate context
mix phx.gen.context Accounts User users email:string password:string

# Generate schema
mix phx.gen.schema User users email:string name:string

# Generate controller
mix phx.gen.html Post posts title:string content:text

# Generate embedded schema
mix phx.gen.embedded Address street:string city:string

Code Quality Tools

Formatting

# Format all code
mix format

# Check if formatted
mix format --check-formatted

# Format specific file
mix format lib/my_app.ex

Linting with Credo

# Install credo
# Add to mix.exs:
# {:credo, "~> 1.7", only: [:dev, :test], runtime: false}

# Run linting
mix credo

# Run with strict mode
mix credo --strict

# Show help
mix credo --help

Type Checking with Dialyzer

# Install dialyxir
# {:dialyxir, "~> 1.4", only: [:dev], runtime: false}

# Run dialyzer
mix dialyzer

# Build PLT (first time)
mix dialyzer --plt

Release & Deployment

Building Releases

# Create release configuration
mix release.init

# Build release
mix release

# Build release for production
MIX_ENV=prod mix release

# Run release
_build/prod/rel/my_app/bin/my_app start

# Console access
_build/prod/rel/my_app/bin/my_app remote

release.exs Configuration

import Config

config :my_app, MyApp.Repo,
  username: System.get_env("DB_USER") || "postgres",
  password: System.get_env("DB_PASSWORD") || "",
  database: System.get_env("DB_NAME") || "my_app_prod",
  hostname: System.get_env("DB_HOST") || "localhost"

Environment Configuration

# Run in development (default)
mix test

# Run in production
MIX_ENV=prod mix test

# Run in test
MIX_ENV=test mix test

# Environment variable
export MIX_ENV=prod
mix compile

Troubleshooting

# Clear all build artifacts
mix clean --deps

# Reinstall dependencies
rm mix.lock
mix deps.get

# Recompile with verbose output
mix compile --verbose

# Check Elixir/OTP versions
elixir --version

# Update mix itself
mix local.hex --force

Best Practices

  • Use semantic versioning for projects
  • Keep dependencies updated regularly
  • Use guards and pattern matching
  • Write property-based tests with ExCheck
  • Document public API with @doc
  • Use Credo for code quality
  • Use Dialyzer for type checking
  • Keep mix.lock in version control

Resources

Last updated: 2025-07-06|Edit on GitHub