Środowisko deweloperskie z Vagrant

Przed Tobą przewodnik po tym, jak zbudować własny obraz Ubuntu 24.04 dla Vagranta i uruchomić na nim w pełni skonfigurowane środowisko developerskie. Artykuł prowadzi przez cały proces: od instalacji systemu, przez hardening, aż po publikację gotowego .box w GitLab Package Registry i jego ponowne użycie.

Note

Jeśli nie słyszałeś wcześniej o Vagrancié — jest to narzędzie do automatycznego tworzenia i zarządzania maszynami wirtualnymi.

Zamiast ręcznie konfigurować środowisko developerskie na każdej maszynie (co jest żmudne i podatne na błędy), opisujesz je w pliku Vagrantfile i uruchamiasz jednym poleceniem: vagrant up.

Co daje to podejście:

• Powtarzalność: identyczne środowisko na każdej maszynie, bez „u mnie działa”
• Izolacja: VM nie brudzi hosta — możesz ją zniszczyć i postawić od nowa
• Automatyzacja: skrypt bootstrap.sh konfiguruje środowisko przy każdym starcie
• Wersjonowanie: obraz .box jest wersjonowany i przechowywany w GitLab

Dlaczego własny obraz zamiast gotowego?

Publiczne boxy z Vagrant Cloud są generyczne — często brakuje w nich naszych kluczy SSH, narzędzi czy konfiguracji sieciowej. Budując własny obraz:

• Kontrola: wiemy dokładnie co jest w środku — żadnych nieznanych pakietów
• Szybkość: nasz box ma już zainstalowane potrzebne narzędzia — vagrant up jest szybszy
• Bezpieczeństwo: hardening robiony przez nas, a nie przez nieznanego maintainera
• Prywatność: obraz w naszym prywatnym GitLab, a nie publicznym rejestrze

⚙️ vagrant

Środowisko developerskie w postaci kodu

Zawartość repozytorium:

• Vagrantfile — konfiguracja VM
• bootstrap.sh — skrypt inicjalizacyjny
• scripts_to_run — lista skryptów provisioningu
• Gotowy obraz w GitLab Package Registry

🔗 Odwiedź

🗄️ GitLab Package Registry

Rejestr paczek do przechowywania obrazów

Przechowuje:

• Obraz .box Ubuntu 24.04
• Wersjonowanie przez semver (1.0.0, 1.1.0, …)
• Dostęp przez API z tokenem PRIVATE-TOKEN
• Integracja z CI/CD — automatyczne publikowanie

🔗 Odwiedź

---

Krok po kroku

1. Przygotowanie maszyny wirtualnej na VirtualBox
2. Instalacja Ubuntu 24.04
3. Wstępny hardening i konfiguracja użytkownika vagrant
4. Przygotowanie do spakowania — czyszczenie systemu
5. Spakowanie VM do pliku .box
6. Dodanie obrazu do lokalnego Vagranta
7. Przygotowanie Vagrantfile
8. Przygotowanie skryptu bootstrap.sh
9. Uruchomienie maszyny developerskiej
10. Publikacja .box w GitLab Package Registry

Pobierz repozytorium zanim zaczniesz:

git clone https://gitlab.com/pl.rachuna-net/devtools/vagrant.git

---

Budowanie obrazu

Hardening i konfiguracja systemu

Po zainstalowaniu świeżego Ubuntu 24.04 na VirtualBoxie, konfigurujemy użytkownika vagrant, SSH i podstawowe pakiety:

echo "vagrant ALL=(ALL) NOPASSWD: ALL" | sudo tee /etc/sudoers.d/vagrant

sudo apt-get update
sudo apt-get dist-upgrade -y
sudo apt install -y openssh-server curl wget sudo
sudo apt install -y build-essential dkms linux-headers-$(uname -r)

mkdir -p /home/vagrant/.ssh
curl -fsSL https://raw.githubusercontent.com/hashicorp/vagrant/master/keys/vagrant.pub \
  -o /home/vagrant/.ssh/authorized_keys
chown -R vagrant:vagrant /home/vagrant/.ssh
chmod 700 /home/vagrant/.ssh
chmod 600 /home/vagrant/.ssh/authorized_keys

sudo apt-get autoremove -y
sudo apt-get clean
sudo rm -rf /var/lib/apt/lists/*

sudo timedatectl set-timezone UTC
sudo locale-gen en_US.UTF-8
sudo swapoff -a
sudo sed -i '/ swap / s/^/#/' /etc/fstab

Dlaczego te kroki?

• Klucz SSH z repozytorium Vagranta to standardowy klucz używany przez vagrant ssh
• Wyłączenie swapu jest wymagane przez Kubernetes (jeśli planujesz go uruchomić w VM)
• Czyszczenie APT zmniejsza rozmiar końcowego obrazu

Przygotowanie do spakowania

Przed utworzeniem .box czyścimy system — usuwamy historię, machine-id i niepotrzebne pliki:

sudo systemctl enable --now ssh

sudo apt autoremove -y
sudo apt clean
history -c

sudo truncate -s 0 /etc/machine-id
sudo rm -f /var/lib/dbus/machine-id

sudo shutdown -h now

Resetowanie machine-id jest kluczowe — każda VM uruchomiona z tego samego obrazu powinna mieć unikalny identyfikator generowany przy pierwszym starcie.

Spakowanie VM do BOX-a

Po wyłączeniu maszyny pakujemy ją poleceniem vagrant package:

# Sprawdź nazwę VM w VirtualBox
VBoxManage list vms

# Spakuj do pliku .box
vagrant package \
  --base "ubuntu-24.04" \
  --output ".box/ubuntu-24.04-1.0.0.box"

Dodanie obrazu do lokalnego Vagranta

vagrant box add ubuntu-24.04-1.0.0 .box/ubuntu-24.04-1.0.0.box

# Sprawdź listę dostępnych obrazów
vagrant box list

---

Konfiguracja środowiska

Vagrantfile

Vagrantfile jest sercem całej konfiguracji — definiuje zasoby VM, sieć i synchronizację folderów:

hostname = ENV['VAGRANT_HOSTNAME'] || 'dev-station'
vm_memory = ENV['VAGRANT_VM_MEMORY'] || 4096
num_cpus = ENV['VAGRANT_NUM_CPUS'] || 2
vm_base_image = ENV['VAGRANT_VM_BASE_IMAGE'] || 'ubuntu-24.04-1.0.0'

Vagrant.configure("2") do |config|

  config.vm.box = vm_base_image
  config.vm.hostname = hostname

  config.vm.provider "virtualbox" do |vb|
    vb.name = hostname
    vb.cpus = num_cpus
    vb.memory = vm_memory
    vb.gui = false
  end

  config.ssh.forward_agent = true
  config.ssh.forward_x11 = true
  config.vm.network "forwarded_port", guest: 22, host: 2222, id: "ssh"

  config.vm.synced_folder ".", "/vagrant", type: "virtualbox"
  config.vm.synced_folder "/userfiles", "/vagrant/userfiles", type: "virtualbox"

  if File.file?("./bootstrap.sh")
    config.vm.provision "shell", path: "./bootstrap.sh", privileged: true, run: "always"
  end
end

Konfiguracja jest sterowana zmiennymi środowiskowymi — możesz dostosować zasoby bez edycji pliku. Aktualna wersja: Vagrantfile

Skrypt bootstrap.sh

Skrypt uruchamiany przy każdym vagrant up — kopiuje pliki użytkownika i wywołuje listę skryptów provisioningu:

#!/bin/env bash
set -euo pipefail

VAGRANT_DIRETORY="/vagrant"
MARKER="/var/lib/vagrant-bootstrap.done"
SCRIPTS_LIST="$VAGRANT_DIRETORY/scripts_to_run"

if [[ -f "${MARKER}" ]]; then
  echo "[bootstrap] already done (${MARKER} exists) - skipping"
  exit 0
fi

echo -e "\033[1;33m===>\033[0m 🚀 Run bootstrap script"

echo -e "\033[1;33m===>\033[0m 📁 Copy userfiles to $HOME"
cp -fr $VAGRANT_DIRETORY/userfiles/. ~/

if [ ! -f "$SCRIPTS_LIST" ]; then
  echo "❌ Scripts list file '$SCRIPTS_LIST' not found!"
  exit 1
fi

while IFS= read -r script; do
  if [ -f "$VAGRANT_DIRETORY/$script" ]; then
    echo -e "\033[1;33m===>\033[0m 🚀 Running script: $VAGRANT_DIRETORY/$script"
    chmod +x "$VAGRANT_DIRETORY/$script"
    bash "$VAGRANT_DIRETORY/$script"
  else
    echo "❌ Script '$script' not found in '$VAGRANT_DIRET/$script'!"
  fi
done < "$SCRIPTS_LIST"

Plik scripts_to_run zawiera listę skryptów do wykonania (po jednym na linię). Aktualna wersja: bootstrap.sh

---

Uruchomienie środowiska

vagrant up

Lub za pomocą gotowych skryptów startowych:

Linux

chmod +x start_vm.bash
./start_vm.bash

Windows

start_vm.bat

Po uruchomieniu możesz śledzić postęp bootrstapowania bezpośrednio w terminalu:

===> 🚀 Run bootstrap script
===> 📁 Copy userfiles to /home/vagrant
===> 🚀 Running script: /vagrant/provisioning/upgrade-ubuntu.bash
===> Upgrade system packages and distribution
===> 🚀 Running script: /vagrant/provisioning/install-packages.bash
===> Install packages

---

Dostęp SSH

SSH jest dostępne na porcie 2222 hosta, przekierowanym do portu 22 w VM. Włączone jest przekazywanie agenta SSH oraz X11.

ssh -p 2222 vagrant@localhost

Wygodniej jest dodać wpis do ~/.ssh/config:

Host dev-station
   HostName 127.0.0.1
   Port 2222
   User vagrant
   IdentityFile /repo/pl.rachuna-net/devtools/vagrant/.vagrant/machines/default/virtualbox/private_key
   ForwardX11 yes

Dzięki temu łączysz się jednym poleceniem:

ssh dev-station

---

Publikacja w GitLab Package Registry

Po zbudowaniu i przetestowaniu obrazu publikujemy go w GitLab, żeby inni mogli z niego korzystać bez budowania od zera:

export GITLAB_URL="https://gitlab.com"
export GITLAB_TOKEN=""
export PROJECT_ID="77501746"
export PACKAGE_NAME="ubuntu-24.04"
export PACKAGE_VERSION="1.0.0"
export FILE_NAME="${PACKAGE_NAME}-${PACKAGE_VERSION}.box"

curl --fail --location -H "PRIVATE-TOKEN: ${GITLAB_TOKEN}" \
  --upload-file ".box/${FILE_NAME}" \
  "${GITLAB_URL}/api/v4/projects/${PROJECT_ID}/packages/generic/${PACKAGE_NAME}/${PACKAGE_VERSION}/${FILE_NAME}"

Użycie opublikowanego obrazu

Jeśli nie chcesz budować obrazu samodzielnie, pobierz gotowy z rejestru:

export GITLAB_URL="https://gitlab.com"
export GITLAB_TOKEN=""
export PROJECT_ID="77501746"
export PACKAGE_NAME="ubuntu-24.04"
export PACKAGE_VERSION="1.0.0"
export FILE_NAME="${PACKAGE_NAME}-${PACKAGE_VERSION}.box"

curl -L -H "PRIVATE-TOKEN: ${GITLAB_TOKEN}" \
  "${GITLAB_URL}/api/v4/projects/${PROJECT_ID}/packages/generic/${PACKAGE_NAME}/${PACKAGE_VERSION}/${FILE_NAME}" \
  -o .box/$FILE_NAME

vagrant box add ubuntu-24.04-1.0.0 .box/ubuntu-24.04-1.0.0.box

vagrant up

---

Zasoby & Linki

Zasób	Czego się nauczysz
Vagrant Docs	Vagrantfile, provisioning, networking
VirtualBox Docs	Zarządzanie VM-ami, snapshoty
GitLab Package Registry	Publikowanie paczek przez API
Nasze repozytorium	Gotowy Vagrantfile i skrypty

---

Maciej Rachuna | rachuna-net.pl

Artykuł opisuje realne środowisko deweloperskie używane w codziennej pracy z infrastrukturą. Vagrantfile, bootstrap.sh i obraz .box są dostępne w repozytorium GitLab i gotowe do użycia.