Autor: [Piotr Wasilewski](/autorzy/piotr-wasilewski) Architekt rozwiązań chmurowych · Zweryfikowano Kwiecień 2026

1.  [Strona główna](/) ›
2.  [Baza wiedzy](/baza-wiedzy/) ›
3.  Vagrant — środowiska deweloperskie

# Vagrant — przenośne środowiska deweloperskie dla programistów

Opublikowano: 10 kwietnia 2026 · Kategoria: VPS / DevOps

"U mnie działa" to jeden z najczęstszych problemów w programowaniu. Vagrant rozwiązuje go przez opisanie środowiska deweloperskiego jako kodu w pliku `Vagrantfile`. Każdy developer w zespole uruchamia identyczną VM jednym poleceniem — bez instalowania ręcznie PHP, Nginx, MySQL czy Node.js w konkretnych wersjach. Vagrant szczególnie błyszczy gdy testujesz konfigurację serwerów (Ansible, Puppet, Salt), potrzebujesz symulować środowisko produkcyjne z systemd, lub projekty wymagają izolacji na poziomie kernela. Ten artykuł pokazuje kompletną konfigurację od Vagrantfile po multi-machine.

## Instalacja Vagrant i VirtualBox

\# Ubuntu / Debian — Vagrant
wget -O- https://apt.releases.hashicorp.com/gpg | \\
  sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb \[signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg\] \\
  https://apt.releases.hashicorp.com $(lsb\_release -cs) main" | \\
  sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update && sudo apt install vagrant -y

# VirtualBox (domyślny provider)
sudo apt install virtualbox -y

# macOS
brew tap hashicorp/tap
brew install hashicorp/tap/vagrant
brew install --cask virtualbox

# Windows (PowerShell jako Administrator)
winget install Hashicorp.Vagrant
winget install Oracle.VirtualBox

# Sprawdź instalację
vagrant --version
vagrant plugin list

# Przydatne pluginy
vagrant plugin install vagrant-vbguest    # Automatyczne VirtualBox Guest Additions
vagrant plugin install vagrant-disksize   # Zmiana rozmiaru dysku
vagrant plugin install vagrant-hostmanager  # Automatyczne /etc/hosts

## Vagrantfile — podstawowa konfiguracja

`Vagrantfile` to plik Ruby opisujący maszynę wirtualną. Zaczyna się od `vagrant init` i jest commitowany do repozytorium — każdy developer uruchamia identyczne środowisko:

\# Inicjalizacja Vagrantfile
vagrant init ubuntu/jammy64

# Vagrantfile — kompletna konfiguracja środowiska LEMP
Vagrant.configure("2") do |config|
  # Box — gotowy obraz Ubuntu 22.04 z Vagrant Cloud
  config.vm.box = "ubuntu/jammy64"
  config.vm.box\_version = ">= 20240101.0.0"

  # Hostname i FQDN
  config.vm.hostname = "dev.local"

  # Forwarded port — dostęp z hosta do VM
  config.vm.network "forwarded\_port", guest: 80, host: 8080, id: "nginx"
  config.vm.network "forwarded\_port", guest: 3306, host: 3306, id: "mysql"

  # Private network — stały IP dla VM
  config.vm.network "private\_network", ip: "192.168.56.10"

  # Shared folders — synchronizacja kodu
  config.vm.synced\_folder "./src", "/var/www/html",
    owner: "www-data", group: "www-data",
    mount\_options: \["dmode=775,fmode=664"\]

  # NFS (szybszy niż VirtualBox default)
  # config.vm.synced\_folder "./src", "/var/www/html", type: "nfs"

  # Provider — zasoby VM
  config.vm.provider "virtualbox" do |vb|
    vb.name   = "lemp-dev"
    vb.memory = 2048    # 2 GB RAM
    vb.cpus   = 2
    vb.gui    = false   # Bez okna GUI (headless)

    # Optymalizacja VirtualBox
    vb.customize \["modifyvm", :id, "--natdnshostresolver1", "on"\]
    vb.customize \["modifyvm", :id, "--natdnsproxy1", "on"\]
  end

  # Provisioner shell — instalacja LEMP
  config.vm.provision "shell", inline: <<-SHELL
    export DEBIAN\_FRONTEND=noninteractive
    apt-get update -q
    apt-get install -yq nginx php8.2-fpm php8.2-mysql mysql-server
    systemctl enable nginx php8.2-fpm mysql
    systemctl start nginx php8.2-fpm mysql
  SHELL
end

## Provisioning przez Ansible

Provisioner Ansible uruchamia playbook Ansible wewnątrz (lub na hoście) przy starcie VM. To idealne rozwiązanie gdy chcesz testować playbooki przed uruchomieniem na produkcji — Vagrant daje identyczne środowisko jak produkcyjny VPS:

\# Vagrantfile z Ansible provisioner
Vagrant.configure("2") do |config|
  config.vm.box = "ubuntu/jammy64"
  config.vm.network "private\_network", ip: "192.168.56.10"

  # Ansible na hoście (wymaga Ansible zainstalowanego na hoście)
  config.vm.provision "ansible" do |ansible|
    ansible.playbook       = "provisioning/playbook.yml"
    ansible.inventory\_path = "provisioning/inventory"
    ansible.limit          = "all"
    ansible.verbose        = "v"
    ansible.extra\_vars = {
      "env" => "development",
      "nginx\_port" => 80,
    }
  end

  # Lub: Ansible lokalnie wewnątrz VM (ansible\_local)
  # — nie wymaga Ansible na hoście, przydatne dla Windows
  config.vm.provision "ansible\_local" do |ansible|
    ansible.playbook = "provisioning/playbook.yml"
    ansible.install\_mode = :pip  # Instaluj Ansible przez pip
    ansible.pip\_args = "ansible-core==2.15.\*"
  end
end

# provisioning/playbook.yml
---
- name: Konfiguracja środowiska deweloperskiego
  hosts: all
  become: yes
  roles:
    - nginx
    - php-fpm
    - mysql

# Użycie:
# vagrant up             # Uruchom VM i zastosuj provisioning
# vagrant provision      # Ponowne provisioning bez restartu VM
# vagrant reload --provision  # Restart + provisioning

## Multi-machine — symulacja środowiska produkcyjnego

\# Vagrantfile — multi-machine (web + db)
Vagrant.configure("2") do |config|
  config.vm.box = "ubuntu/jammy64"

  # Serwer webowy
  config.vm.define "web" do |web|
    web.vm.hostname = "web.local"
    web.vm.network "private\_network", ip: "192.168.56.10"
    web.vm.network "forwarded\_port", guest: 80, host: 8080

    web.vm.provider "virtualbox" do |vb|
      vb.name   = "web-dev"
      vb.memory = 1024
      vb.cpus   = 1
    end

    web.vm.provision "ansible" do |ansible|
      ansible.playbook = "provisioning/web.yml"
    end
  end

  # Serwer bazy danych
  config.vm.define "db" do |db|
    db.vm.hostname = "db.local"
    db.vm.network "private\_network", ip: "192.168.56.11"

    db.vm.provider "virtualbox" do |vb|
      vb.name   = "db-dev"
      vb.memory = 1024
      vb.cpus   = 1
    end

    db.vm.provision "ansible" do |ansible|
      ansible.playbook = "provisioning/db.yml"
    end
  end
end

# Komendy multi-machine
vagrant up           # Uruchom wszystkie VM
vagrant up web       # Uruchom tylko "web"
vagrant ssh web      # Połącz się z VM "web"
vagrant halt db      # Zatrzymaj VM "db"
vagrant status       # Status wszystkich VM
vagrant destroy -f   # Usuń wszystkie VM (bez pytania)

## Vagrant Cloud — gotowe boxes

Vagrant Cloud (`app.vagrantup.com`) to publiczne repozytorium gotowych boxes — obrazów VM. Najpopularniejsze boxes dla developerów:

Box

Opis

Rozmiar

Użycie

`ubuntu/jammy64`

Ubuntu 22.04 LTS

~600 MB

Ogólne, PHP, Node.js

`ubuntu/focal64`

Ubuntu 20.04 LTS

~600 MB

Starsze projekty

`debian/bookworm64`

Debian 12

~400 MB

Minimalistyczne środowisko

`generic/ubuntu2204`

Ubuntu 22.04 (VMware/libvirt)

~900 MB

Multi-provider support

`geerlingguy/ubuntu2204`

Ubuntu 22.04 z Ansible

~1.2 GB

Testowanie ról Ansible

\# Zarządzanie boxes
vagrant box add ubuntu/jammy64          # Pobierz box
vagrant box list                        # Wylistuj zainstalowane boxes
vagrant box update                      # Zaktualizuj wszystkie boxes
vagrant box remove ubuntu/jammy64       # Usuń box

# Budowanie własnego box z Packer
# packer build ubuntu.pkr.hcl
# vagrant box add my-lemp ./output/package.box

# Wydajność — porady
# 1. Używaj NFS zamiast VirtualBox shared folders
config.vm.synced\_folder ".", "/vagrant", type: "nfs"
# 2. Cachuj apt packages (vagrant-cachier plugin)
if Vagrant.has\_plugin?("vagrant-cachier")
  config.cache.scope = :box
end
# 3. Zmień tryb synchronizacji na rsync dla read-heavy
config.vm.synced\_folder "./dist", "/var/www/html/dist", type: "rsync"

## Najczęstsze pytania

Do czego służy Vagrant i kiedy go używać? +

Vagrant to narzędzie do tworzenia i zarządzania przenośnymi środowiskami deweloperskimi w postaci maszyn wirtualnych. Rozwiązuje problem "u mnie działa" — Vagrantfile opisuje środowisko jako kod, każdy developer uruchamia identyczną VM. Używaj Vagrant gdy: potrzebujesz pełnego systemu Linux (nie kontenera Docker), testujesz konfigurację serwerów (Ansible, Puppet), potrzebujesz izolacji między projektami z różnymi wersjami PHP/Node/Python, lub gdy projekt wymaga specyficznego kernela. Docker Dev Containers jest lepszy dla lżejszych środowisk.

Jakie providery obsługuje Vagrant? +

VirtualBox (domyślny, darmowy — najczęstsze użycie), VMware Workstation/Fusion (płatny plugin, szybszy), Hyper-V (Windows 10/11 Pro), libvirt/KVM (Linux, dobra wydajność), Docker (Vagrant jako wrapper nad kontenerami), AWS/Azure/GCP (VM w chmurze). Zmieniasz provider przez \`vagrant up --provider=vmware\_desktop\`. VirtualBox jest najłatwiejszy do startu. Libvirt/KVM ma lepszą wydajność na Linux niż VirtualBox.

Jak działa synchronizacja folderów (shared folders) w Vagrant? +

Vagrant synchronizuje katalog roboczy hosta do /vagrant w VM. Możesz konfigurować dodatkowe foldery: config.vm.synced\_folder "./src", "/var/www/html". Typy synchronizacji: VirtualBox shared folders (domyślny, wolny na dużych projektach), NFS (szybszy na Linux/macOS, wymaga sudo), rsync (jednokierunkowy, najszybszy dla read-heavy workloadów), SMB (Windows). Dla projektów PHP/Python/Node NFS znacząco przyspiesza wykonanie kodu.

Czym różni się Vagrant od Docker Dev Containers? +

Docker Dev Containers to lekkie środowisko deweloperskie oparte na kontenerach Docker (własny filesystem, ale współdzielony kernel hosta). Jest szybszy i zużywa mniej zasobów. Vagrant tworzy pełną VM z własnym kernelem — wolniejszy start, więcej RAM, ale lepszą izolację. Dev Containers są lepsze dla: aplikacji webowych, microusług, gdy projekt ma Dockerfile. Vagrant jest lepszy dla: testowania konfiguracji serwera, symulacji środowiska produkcyjnego z Nginx/systemd, projektów wymagających specificznego kernela lub systemd.

Jak konfigurować multi-machine Vagrant (wiele VM)? +

Vagrant obsługuje konfigurację wielu VM w jednym Vagrantfile przez bloki \`config.vm.define\`. Każda VM ma własną sieć, provisioning i zasoby. Przydatne do symulowania środowisk produkcyjnych: \`vagrant up web\` uruchamia tylko VM "web", \`vagrant up\` uruchamia wszystkie. Możesz definiować prywatną sieć między VM (private\_network) by mogły się komunikować. Multi-machine jest idealny do testowania architektury master/slave baz danych lub load balancera.

## Sprawdź oferty pasujące do tego scenariusza

Poniżej masz szybkie przejścia do ofert i stron z kodami rabatowymi tam, gdzie są dostępne.

Contabo

VPS do testowania konfiguracji Ansible zanim wdrożysz na produkcję

Test + Prod

[Aktywuj rabat →](/out/contabo)

#Reklama · link partnerski

[Zobacz kod rabatowy →](/kody-rabatowe/contabo)

ProSerwer.pl

Polski VPS jako środowisko produkcyjne po testach w Vagrant

Polski VPS

[Aktywuj rabat →](/out/proserwer-pl)

#Reklama · link partnerski

[Zobacz kod rabatowy →](/kody-rabatowe/proserwer)

Mikr.us

Najtańszy VPS dla deweloperów — gdy Vagrant to za dużo zasobów lokalnie

Budżetowy

[Aktywuj rabat →](/out/mikrus)

#Reklama · link partnerski

[Zobacz kod rabatowy →](/kody-rabatowe/mikrus)

## Powiązane strony

-   [Ansible Roles i Galaxy — tworzenie i używanie ról](/baza-wiedzy/ansible-roles-galaxy)
-   [Docker na VPS — instalacja, kontenery i Docker Compose](/baza-wiedzy/docker-na-vps)
-   [Packer — budowanie spójnych obrazów VM dla VPS i chmury](/baza-wiedzy/packer-vm-images)
-   [Wszystkie artykuły](/baza-wiedzy/)