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

⚡ W skrócie · 9 min czytania

-   Vagrant: Vagrantfile (box/network/provision), providers (VirtualBox/VMware/Hyper-V), provisioning shell i Ansible, multi-machine setup, shared folders, Vagrant Cloud, porównanie z Dev Containers.
-   Instalacja Vagrant i VirtualBox.
-   Vagrantfile - podstawowa konfiguracja.
-   Provisioning przez Ansible.
-   Multi-machine - symulacja środowiska produkcyjnego.

"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 "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 "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 "Mikr.us")

#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/)
-   [Puppet - deklaratywne zarządzanie konfiguracją infrastruktury
    
    Puppet: architektura master/agent, Puppet DSL (resources/classes/modules), Forge, Hiera (data hierarchy), cykl agenta…
    
    ](/baza-wiedzy/puppet-infrastruktura/)
-   [SaltStack - zarządzanie konfiguracją serwerów z master/minion
    
    SaltStack: architektura Salt master/minion z ZeroMQ, instalacja, targeting minionów (glob/grain/compound), States SLS…
    
    ](/baza-wiedzy/saltstack-konfiguracja/)
-   [Proxmox VE - wirtualizacja KVM i LXC dla serwerów dedykowanych
    
    Proxmox VE: instalacja, tworzenie VM i kontenerów LXC, storage ZFS/LVM/Ceph, networking bridges/VLAN, backup z Proxmox…
    
    ](/baza-wiedzy/proxmox-ve-wirtualizacja/)
-   [Jaki VPS wybrać?](/jaki-vps-wybrac/)

Autor: [Redakcja HostGrade.pl](/autorzy/) Zespół redakcyjny · Aktualizacja: 10 kwietnia 2026

Artykuły HostGrade.pl przygotowuje i aktualizuje redakcja serwisu. Ceny startowe, ceny odnowienia i warunki planów sprawdzamy w cennikach i regulaminach dostawców, a potem liczymy całkowity koszt za 2 lata (cena startowa plus odnowienia). Zasady zbierania danych i liczenia kosztów opisujemy na stronie Metodologia. Linki partnerskie oznaczamy jako #reklama.

[O redakcji i metodologii →](/autorzy/)