ITBlog

1. Architektura i składniki pełnego środowiska GNS3

Często popełnianym błędem jest założenie, że instalacja samego pakietu gns3-server wystarcza do pracy. Serwer GNS3 to jedynie kontroler i interfejs API zarządzający zewnętrznymi emulatorami. „Pełny GNS3” wymaga następujących modułów wykonawczych:

2. Krok 1: Włączenie obsługi 32-bitów (i386) dla Cisco IOU

Obrazy Cisco IOU (zarówno L2 dla przełączników, jak i L3 dla routerów) zostały skompilowane jako 32-bitowe programy ELF. Na czystym 64-bitowym Debianie próba ich uruchomienia kończy się mylącym błędem powłoki: No such file or directory, mimo że plik istnieje. Wynika to z braku 32-bitowego interpretera dynamicznego.

Włącz wieloarchitekturowość (Multiarch) i zaktualizuj listy pakietów:

# 1. Włączenie architektury i386
sudo dpkg --add-architecture i386

# 2. Aktualizacja indeksów APT
sudo apt update

# 3. Instalacja 32-bitowych bibliotek bazowych i OpenSSL
# Użycie maski 'libssl3*:i386' gwarantuje zgodność zarówno z Debianem 12 (libssl3), jak i Debianem 13 / Ubuntu 24+ (libssl3t64)
sudo apt install -y libc6:i386 libstdc++6:i386 'libssl3*:i386'

sudo ln -sf /usr/lib/i386-linux-gnu/libcrypto.so.3 /usr/lib/i386-linux-gnu/libcrypto.so.4

3. Krok 2: Instalacja pakietów bazowych i narzędzi deweloperskich

Kompilacja emulatorów (Dynamips, uBridge, iouyap) oraz obsługa sieci wymaga zestawu kompilatorów C/C++, bibliotek nagłówkowych oraz bibliotek pcap i elf:

sudo apt install -y \
    build-essential \
    cmake \
    git \
    gcc \
    make \
    pkg-config \
    libelf-dev \
    libpcap-dev \
    libcap2-bin \
    zlib1g-dev \
    libssl-dev \
    python3 \
    python3-pip \
    pipx \
    libbsd-dev \
    bison \
    flex \
    telnet \
    curl

4. Krok 3: Konfiguracja sprzętowej wirtualizacji KVM / QEMU

GNS3 uruchamia zaawansowane routery i maszyny wirtualne (Cisco CSR1000v, Cisco IOSvL2, Arista vEOS) wewnątrz emulatora QEMU. Aby maszyny działały płynnie, niezbędna jest sprzętowa akceleracja KVM (Intel VT-x lub AMD-V).

# 1. Instalacja QEMU i narzędzi pomocniczych
sudo apt install -y qemu-system-x86 qemu-utils cpu-checker

# 2. Sprawdzenie wsparcia wirtualizacji przez procesor
kvm-ok

Jeśli wynik polecenia to KVM acceleration can be used, akceleracja działa. Następnie dodaj bieżącego użytkownika (oraz użytkownika, pod którym będzie działać GNS3) do grupy kvm:

sudo usermod -aG kvm $USER

5. Krok 4: Instalacja Docker i Wireshark z uprawnieniami

Środowisko laboratoryjne wymaga analizatora ruchu sieciowego oraz możliwości uruchamiania kontenerów:

# 1. Automatyczne ustawienie uprawnień dumpcap dla zwykłych użytkowników (unika blokowania skryptu)
echo "wireshark-common wireshark-common/install-setuid boolean true" | sudo debconf-set-selections

# 2. Instalacja Wiresharka oraz silnika Docker
sudo DEBIAN_FRONTEND=noninteractive apt install -y wireshark tshark docker.io

# 3. Przypisanie użytkownika do odpowiednich grup
sudo usermod -aG wireshark,docker,kvm $USER

6. Krok 5: Instalacja serwera GNS3 za pomocą pipx (zgodnie z PEP 668)

Debian 12 Bookworm wdraża standard PEP 668, który blokuje instalację pakietów za pomocą bezpośredniego pip install w środowisku systemowym (błąd externally-managed-environment). Zabezpiecza to menedżer APT przed uszkodzeniem bibliotek Pythona.

Oficjalnym i zalecanym sposobem instalacji GNS3 jest narzędzie pipx, które instaluje aplikację w izolowanym środowisku wirtualnym i tworzy dowiązania w katalogu ~/.local/bin:

# 1. Konfiguracja zmiennych środowiskowych PATH dla pipx
pipx ensurepath

# 2. Instalacja serwera GNS3
pipx install gns3-server

# 3. (Opcjonalnie) Jeśli na tej samej maszynie jest środowisko graficzne i chcesz klienta GUI:
pipx install gns3-gui

# 4. Sprawdzenie poprawności instalacji
~/.local/bin/gns3server --version

Jeśli serwer ma być dostępny globalnie dla wszystkich użytkowników i demonów systemowych, utwórz dowiązanie do /usr/local/bin:

sudo ln -sf $(which gns3server || echo $HOME/.local/bin/gns3server) /usr/local/bin/gns3server

7. Krok 6: Kompilacja i instalacja komponentów sieciowych

6.1 Dynamips (emulacja routerów Cisco IOS)

Dynamips nie jest już dostępny w oficjalnych pakietach Debiana. Należy go skompilować ze źródeł projektu GNS3:

cd /tmp
git clone https://github.com/GNS3/dynamips.git
cd dynamips
mkdir build && cd build
cmake ..
make -j$(nproc)
sudo make install

# Nadanie uprawnień do surowych gniazd sieciowych
sudo setcap cap_net_admin,cap_net_raw=ep /usr/local/bin/dynamips

# Weryfikacja
dynamips -H 127.0.0.1:54321 &
sleep 1
pkill dynamips

6.2 uBridge (mostkowanie interfejsów)

uBridge jest kluczowy dla łączenia emulatorów ze sobą i z kartami sieciowymi hosta:

cd /tmp
git clone https://github.com/GNS3/ubridge.git
cd ubridge
make
sudo make install

# Upewnij się, że binarka ma odpowiednie uprawnienia
sudo setcap cap_net_admin,cap_net_raw=ep /usr/local/bin/ubridge

6.3 VPCS (wirtualne stacje robocze)

VPCS można zainstalować bezpośrednio z repozytorium APT w Debianie:

sudo apt install -y vpcs

6.4 iouyap oraz konfiguracja pod Cisco IOU

Narzędzie iouyap służy do łączenia obrazów IOU z uBridge i gniazdami sieciowymi:

cd /tmp
rm -rf iouyap
git clone https://github.com/GNS3/iouyap.git
cd iouyap
make clean
make CFLAGS="-Wall -fcommon"
sudo make install

8. Krok 7: Generowanie licencji dla Cisco IOU (.iourc)

Cisco IOU wymaga ważnego pliku licencji .iourc. Licencja jest wyliczana na podstawie unikalnego identyfikatora hostid oraz nazwy komputera (hostname).

Zapisz i uruchom poniższy sprawdzony skrypt generatora licencji w Pythonie 3:

cat << 'EOF' > ~/iou_keygen.py
#!/usr/bin/env python3
import os
import socket
import struct
import hashlib

IOU_PAD1 = b'\x4B\x58\x21\x81\x56\x7B\x0D\xF3\x21\x43\x9B\x7E\xAC\x1D\xE6\x8A'
IOU_PAD2 = b'\x80' + 39 * b'\x00'

hostid = os.popen("hostid").read().strip()
hostname = socket.gethostname()
ioukey = int(hostid, 16)

for char in hostname:
    ioukey += ord(char)

md5input = IOU_PAD1 + IOU_PAD2 + struct.pack('!I', ioukey & 0xFFFFFFFF) + IOU_PAD1
license_key = hashlib.md5(md5input).hexdigest()[:16]

iourc_content = f"[license]\n{hostname} = {license_key};\n"
iourc_path = os.path.expanduser("~/.iourc")

with open(iourc_path, "w") as f:
    f.write(iourc_content)

print("=" * 50)
print(f"Wygenerowano poprawny plik licencji: {iourc_path}")
print(f"Host ID : {hostid}")
print(f"Hostname: {hostname}")
print(f"Klucz   : {license_key}")
print("Zawartość pliku ~/.iourc:")
print(iourc_content)
print("=" * 50)
EOF

# Wykonanie skryptu generującego
python3 ~/iou_keygen.py

9. Krok 8: Konfiguracja i uruchomienie usługi systemowej (systemd)

Serwer GNS3 powinien uruchamiać się automatycznie w tle jako usługa systemowa systemd. Serwer nigdy nie powinien działać z uprawnieniami użytkownika root.

9.1 Plik konfiguracyjny serwera (~/.config/GNS3/3.0/gns3_server.conf)

Utwórz domyślny plik konfiguracyjny określający katalogi, porty oraz dane uwierzytelniania:

mkdir -p ~/.config/GNS3/3.0
mkdir -p ~/GNS3/projects ~/GNS3/images ~/GNS3/symbols ~/GNS3/configs

cat << EOF > ~/.config/GNS3/3.0/gns3_server.conf
[Server]
host = 0.0.0.0
port = 3080
images_path = $HOME/GNS3/images
projects_path = $HOME/GNS3/projects
report_errors = False
console_start_port_range = 2001
console_end_port_range = 5000
udp_start_port_range = 30000
udp_end_port_range = 40000
ubridge_path = /usr/local/bin/ubridge
auth = True
user = admin
password = admin

[Dynamips]
dynamips_path = /usr/local/bin/dynamips
allocate_aux_console_ports = False
mmap_support = True
sparse_memory_support = True
ghost_ios_support = True

[IOU]
iouyap_path = /usr/local/bin/iouyap
iourc_path = $HOME/.iourc
license_check = True

[VPCS]
vpcs_path = /usr/bin/vpcs
EOF

9.2 Definicja usługi systemowej (/etc/systemd/system/gns3.service)

Zarejestruj usługę systemową, podstawiając nazwę swojego użytkownika (w przykładzie zmienna $USER):

CURRENT_USER=$(whoami)
CURRENT_HOME=$HOME

sudo bash -c "cat << EOF > /etc/systemd/system/gns3.service
[Unit]
Description=GNS3 server
After=network.target

[Service]
Type=simple
User=${CURRENT_USER}
Group=${CURRENT_USER}
WorkingDirectory=${CURRENT_HOME}
Environment=\"HOME=${CURRENT_HOME}\"
ExecStart=/usr/local/bin/gns3server
Restart=on-abort

[Install]
WantedBy=multi-user.target
EOF"

# Przeładowanie systemd i aktywacja usługi
sudo systemctl daemon-reload
sudo systemctl enable gns3
sudo systemctl restart gns3

# Sprawdzenie statusu
systemctl status gns3

10. Krok 9: Dostęp do interfejsu Web UI i rozwiązywanie problemów sieciowych

GNS3 v3.0+ posiada wbudowany nowoczesny interfejs przeglądarkowy (Web UI). Domyślnie serwer nasłuchuje na porcie 3080 (protokół HTTP).

10.1 Prawidłowy adres dostępu

• Jeśli łączysz się z tej samej maszyny: http://localhost:3080
• Jeśli łączysz się z sieci lokalnej: http://<IP_SERWERA>:3080 (np. http://192.168.51.99:3080)

ssh -L 3080:localhost:3080 uzytkownik@IP_SERWERA

11. Krok 10: Konfiguracja bezpiecznego połączenia HTTPS (SSL/TLS)

Włączenie szyfrowania HTTPS rozwiązuje problem automatycznego wymuszania bezpiecznych połączeń przez nowoczesne przeglądarki, chroni dane uwierzytelniające przesyłane do serwera, a w wariancie z Nginx (port 443) pozwala ominąć blokady niestandardowych portów na routerach i zaporach sieciowych.

Wariant A: Nginx jako Reverse Proxy z SSL na standardowym porcie 443 (Zalecane)

Jest to najbardziej niezawodne rozwiązanie produkcyjne. Nginx przyjmuje ruch po standardowym, bezpiecznym porcie 443, automatycznie przekierowuje zapytania ze zwykłego portu 80 na 443, obsługuje połączenia WebSockets wymagane przez konsolę GNS3 i przekazuje ruch lokalnie do serwera GNS3 (127.0.0.1:3080).

# 1. Sprawdzenie, czy porty 80 i 443 są wolne (jeśli działa Apache, zatrzymaj go: sudo systemctl stop apache2 && sudo systemctl disable apache2)
sudo ss -tulpn | grep -E ':80|:443'

# 2. Instalacja serwera Nginx oraz narzędzia OpenSSL
sudo apt install -y nginx openssl

# 3. Wygenerowanie klucza prywatnego i samopodpisanego certyfikatu SSL
sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
    -keyout /etc/ssl/private/gns3-selfsigned.key \
    -out /etc/ssl/certs/gns3-selfsigned.crt \
    -subj "/C=PL/ST=Polska/L=Warszawa/O=Lab/CN=gns3.local"

# 4. Utworzenie konfiguracji wirtualnego hosta Nginx
sudo bash -c 'cat << "EOF" > /etc/nginx/sites-available/gns3
server {
    listen 80;
    server_name _;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name _;

    ssl_certificate /etc/ssl/certs/gns3-selfsigned.crt;
    ssl_certificate_key /etc/ssl/private/gns3-selfsigned.key;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    # Zwiększenie limitu wysyłanych plików (niezbędne przy wgrywaniu obrazów ISO/QCOW2)
    client_max_body_size 4096M;

    location / {
        proxy_pass http://127.0.0.1:3080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # Pełna obsługa protokołu WebSocket (konsola terminalowa i notyfikacje)
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";

        proxy_read_timeout 86400s;
        proxy_send_timeout 86400s;
    }
}
EOF'

# 5. Aktywacja konfiguracji i restart Nginx
sudo ln -sf /etc/nginx/sites-available/gns3 /etc/nginx/sites-enabled/gns3
sudo rm -f /etc/nginx/sites-enabled/default
sudo nginx -t && sudo systemctl restart nginx

Po wykonaniu powyższych kroków serwer dostępny jest bezpośrednio pod adresem:

https://<IP_SERWERA> (bez konieczności podawania jakiegokolwiek numeru portu w adresie).

Wariant B: Natywna obsługa SSL bezpośrednio w serwerze GNS3 (Port 3080)

Jeśli nie chcesz instalować serwera Nginx, możesz włączyć obsługę SSL bezpośrednio w demonie gns3server:

# 1. Wygenerowanie certyfikatu w katalogu konfiguracyjnym użytkownika
mkdir -p ~/.config/GNS3/3.0/ssl
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
    -keyout ~/.config/GNS3/3.0/ssl/server.key \
    -out ~/.config/GNS3/3.0/ssl/server.crt \
    -subj "/C=PL/ST=Polska/L=Warszawa/O=Lab/CN=gns3.local"

# 2. Dodanie wpisów SSL do pliku ~/.config/GNS3/3.0/gns3_server.conf w sekcji [Server]
cat << EOF >> ~/.config/GNS3/3.0/gns3_server.conf
ssl = True
certfile = $HOME/.config/GNS3/3.0/ssl/server.crt
keyfile = $HOME/.config/GNS3/3.0/ssl/server.key
EOF

# 3. Zrestartowanie usługi systemowej
sudo systemctl restart gns3

W tym wariancie połączenie nawiązuje się przez protokół HTTPS na porcie 3080:

https://<IP_SERWERA>:3080

11.3 Łączenie z poziomu przeglądarki i klienta GNS3 Desktop GUI

• W przeglądarce internetowej: Ponieważ certyfikat został wygenerowany lokalnie (jest samopodpisany), przeglądarka wyświetli ostrzeżenie o bezpieczeństwie. Należy kliknąć Zaawansowane (Advanced) → Przejdź do strony (niebezpieczne) (Proceed to site).
• W aplikacji desktopowej GNS3 GUI: W menu wejdź w Edit → Preferences → Server. Zaznacz opcję Enable SSL, wprowadź adres IP serwera oraz port (443 w przypadku wariantu A lub 3080 w przypadku wariantu B).

12. Krok 11: Wgrywanie obrazów systemów (IOS, IOU, QEMU) za pomocą SCP i WinSCP

GNS3 przechowuje obrazy wirtualnych urządzeń w ustrukturyzowanych podkatalogach wewnątrz folderu ~/GNS3/images/. Aby serwer poprawnie wykrył i skojarzył obrazy z odpowiednimi emulatorami, każdy plik musi trafić do dedykowanego katalogu:

12.0 Zasoby obrazów systemów Cisco i inne

Obrazy systemów L2, L3 Cisco i inne znajdziesz w poniższym łączu:

https://github.com/hegdepavankumar/Cisco-Images-for-GNS3-and-EVE-NG

12.1 Przygotowanie struktury katalogów na serwerze

Przed przesłaniem plików upewnij się, że katalogi docelowe istnieją na serwerze:

mkdir -p ~/GNS3/images/IOS ~/GNS3/images/IOU ~/GNS3/images/QEMU

12.2 Wgrywanie obrazów za pomocą SCP (Konsola Linux / macOS / PowerShell Windows)

Narzędzie scp przesyła pliki bezpośrednio przez protokół SSH. Z poziomu swojego komputera lokalnego wykonaj:

# 1. Wgranie routera Cisco 7200 (Dynamips) do katalogu IOS:
scp c7200-adventerprisek9-mz.152-4.S6.image yyy@192.168.51.99:~/GNS3/images/IOS/

# 2. Wgranie przełącznika warstwy 2 Cisco IOU (L2 Switch) do katalogu IOU:
scp i86bi-linux-l2-upk9-15.0b.bin yyy@192.168.51.99:~/GNS3/images/IOU/

# 3. Wgranie routera Cisco IOU (L3 Router) do katalogu IOU:
scp i86bi-linux-l3-adventerprisek9-15.4.1T.bin yyy@192.168.51.99:~/GNS3/images/IOU/

# 4. Wgranie firewalla Cisco ASAv do katalogu QEMU:
scp asav981.qcow2 yyy@192.168.51.99:~/GNS3/images/QEMU/

12.3 Wgrywanie obrazów za pomocą WinSCP (Graficzny klient dla Windows)

Jeśli preferujesz aplikację okienkową z interfejsem przeciągnij-i-upuść (Drag & Drop), skorzystaj z darmowego programu WinSCP:

1. Konfiguracja sesji logowania w WinSCP:
   • Protokół pliku: SFTP (lub SCP)
   • Nazwa hosta: Adres IP Twojego serwera Debiana (np. 192.168.51.99 lub localhost jeśli korzystasz z tunelu SSH)
   • Numer portu: 22 (lub port lokalny tunelu)
   • Nazwa użytkownika: yyy (lub Twój użytkownik na serwerze)
   • Hasło: Hasło użytkownika
   • Kliknij przycisk Logowanie.
2. Nawigacja i transfer plików:
   • W lewym panelu WinSCP przejdź do folderu na swoim dysku Windows, gdzie zapisałeś pobrane obrazy z repozytorium Cisco.
   • W prawym panelu przejdź do katalogu docelowego na serwerze: /home/yyy/GNS3/images/.
   • Wejdź do podfolderu IOS, IOU lub QEMU i przeciągnij odpowiednie pliki.

chmod +x ~/GNS3/images/IOU/*.bin

12.4 Przygotowanie, rozpakowywanie i konwersja obrazów (IOS, IOU, QEMU, VDI, VMDK)

Pobrane obrazy systemów sieciowych często występują w archiwach lub formatach innych hiperwizorów (VMware, VirtualBox). Poniżej opisano szczegółowe postępowanie dla każdego przypadku:

A. Cisco IOU (L2 Switch oraz L3 Router) – Tylko rozpakowanie

Obrazy Cisco IOU to natywne 32-bitowe pliki binarne Linuksa skompilowane dla architektury x86. Nie należy ich konwertować na żaden format wirtualnych dysków.

• Jeśli pobrany plik znajduje się w archiwum .zip, .tar.gz lub .7z, rozpakuj go:

  # Rozpakowanie archiwum zip
  unzip Cisco_IOU_L2.zip -d ~/GNS3/images/IOU/
  
  # Rozpakowanie archiwum tar.gz
  tar -xzvf Cisco_IOU_L3.tar.gz -C ~/GNS3/images/IOU/
  
  # Nadanie prawa do uruchomienia (bezwzględnie wymagane)
  chmod +x ~/GNS3/images/IOU/*.bin

• Otrzymany plik z rozszerzeniem .bin (np. i86bi-linux-l2-upk9-15.0b.bin) jest natychmiast gotowy do użycia przez GNS3.

B. Cisco IOS (Dynamips) – Rozpakowanie archiwów i obrazów

Klasyczne obrazy routerów Cisco (serie 7200, 3725, 3640) dostarczane są z rozszerzeniem .bin lub .image:

• Pliki .bin to najczęściej samorozpakowujące się archiwa IOS. Dynamips potrafi je uruchomić bezpośrednio, ale zalecaną praktyką jest ich dekompresja do czystego pliku .image przy użyciu polecenia unzip:

  # Wypakowanie surowego obrazu IOS z samorozpakowującego się pliku bin:
  unzip -p c7200-adventerprisek9-mz.124-24.T5.bin > ~/GNS3/images/IOS/c7200-adventerprisek9-mz.124-24.T5.image

  Zaleta: Rozpakowany obraz .image startuje w emulatorze Dynamips natychmiast, bez konieczności rozpakowywania w pamięci RAM serwera przy każdym włączeniu routera.

C. Obrazy dla QEMU / KVM – Dlaczego format QCOW2 jest standardem?

Dla emulatora QEMU (używanego dla Cisco vIOS, ASAv, XRv, FortiGate, MikroTik, Linux) format QCOW2 (QEMU Copy-On-Write wersja 2) jest formatem podstawowym i wysoce rekomendowanym:

• Mechanizm Copy-On-Write (warstwy różnicowe): GNS3 nie modyfikuje oryginalnego pliku bazowego w ~/GNS3/images/QEMU/. Podczas tworzenia projektu serwer tworzy mały plik różnicowy dla każdego węzła. Dziesięć routerów o rozmiarze 5 GB każdy zużywa na dysku zaledwie 5 GB (baza) + po kilkanaście megabajtów na bieżące zmiany konfiguracyjne każdego węzła!
• Cienkie alokowanie (Thin Provisioning): Plik na dysku zajmuje tylko tyle miejsca, ile faktycznie zapisano danych, a nie zadeklarowany wirtualny rozmiar dysku.

D. Konwersja obrazów VDI, VMDK, OVA i RAW do formatu QCOW2

Do konwersji dysków służy narzędzie qemu-img (z pakietu qemu-utils):

1. Konwersja dysku VirtualBox (VDI → QCOW2):

Choć QEMU potrafi odczytać plik .vdi, nie pozwala GNS3 na pełne i wydajne tworzenie migawek Copy-On-Write. Należy go przekonwertować:

qemu-img convert -f vdi -O qcow2 -p dysk-virtualbox.vdi ~/GNS3/images/QEMU/dysk.qcow2

2. Konwersja dysku VMware (VMDK → QCOW2):

Obrazy Cisco vIOS lub urządzenia firewall często udostępniane są jako dyski .vmdk:

qemu-img convert -f vmdk -O qcow2 -p dysk-vmware.vmdk ~/GNS3/images/QEMU/urzadzenie.qcow2

3. Wypakowanie i konwersja maszyn OVA (Open Virtualization Appliance):

Plik z rozszerzeniem .ova to w rzeczywistości standardowe archiwum TAR zawierające plik opisu maszyny (.ovf) oraz dysk (.vmdk):

# Krok 1: Wypakowanie zawartości archiwum OVA
tar -xvf Cisco_ASAv.ova

# Krok 2: Konwersja wypakowanego pliku .vmdk do formatu .qcow2
qemu-img convert -f vmdk -O qcow2 -p Cisco_ASAv-disk1.vmdk ~/GNS3/images/QEMU/asav981.qcow2

# Krok 3: Usunięcie tymczasowych plików instalatora
rm -f *.ovf *.vmdk *.mf

4. Konwersja surowego obrazu RAW / IMG (RAW → QCOW2):

qemu-img convert -f raw -O qcow2 -p system.img ~/GNS3/images/QEMU/system.qcow2

5. Przydatne opcje narzędzia qemu-img:

• -p : wyświetla procentowy pasek postępu konwersji (np. (45.20/100%)).
• -c : włącza kompresję klastrów zlib (znacznie redukuje rozmiar pliku wynikowego na dysku).
• Weryfikacja parametrów obrazu po konwersji:

  qemu-img info ~/GNS3/images/QEMU/asav981.qcow2

  Polecenie wyświetli rzeczywisty format (file format: qcow2), rozmiar wirtualny oraz faktyczną przestrzeń zajmowaną na dysku.

12.5 Tworzenie szablonów (Templates) w interfejsie GNS3 Web UI

Po przesłaniu i ewentualnej konwersji plików na serwerze, należy zarejestrować je w GNS3 jako szablony urządzeń:

1. Otwórz w przeglądarce Web UI GNS3 (http://<IP>:3080 lub https://<IP>).
2. Po lewej stronie kliknij ikonę Templates (lub zębatkę Settings → Templates), a następnie kliknij Add template.
3. Wybierz opcję Manually create a new template i kliknij Next.
4. Wybierz technologię:
   • Cisco IOU: Wybierz typ L2 image dla przełącznika lub L3 image dla routera, a z listy rozwijanej wskaż wgrany plik .bin.
   • Dynamips: Wybierz model (np. c7200, c3725), wskaż plik .image i koniecznie oblicz wartość Idle-PC (przycisk Idle-PC finder), aby emulowany procesor Cisco nie obciążał w 100% rdzeni procesora serwera.
   • QEMU: Wybierz architekturę x86_64, przypisz pamięć RAM (np. 2048 MB dla ASAv) i wskaż plik .qcow2 jako dysk podstawowy.
5. Kliknij Finish. Nowe urządzenie pojawi się w przyborniku i jest gotowe do przeciągania na pole projektu.

13. Krok 12: Praktyczna weryfikacja poprawności instalacji

Aby upewnić się, że całe środowisko działa niezawodnie, wykonaj szybki zestaw testów weryfikacyjnych:

# 1. Sprawdzenie, czy serwer nasłuchuje na porcie 3080
ss -tulpn | grep 3080

# 2. Odpytanie interfejsu REST API o wersję
curl -s http://admin:admin@localhost:3080/v3/version

# 3. Sprawdzenie uprawnień ubridge i dynamips
getcap /usr/local/bin/ubridge
getcap /usr/local/bin/dynamips
# Powinno zwrócić: cap_net_admin,cap_net_raw=ep

# 4. Sprawdzenie obecności 32-bitowej biblioteki crypto dla IOU
ls -l /usr/lib/i386-linux-gnu/libcrypto.so.4

# 5. Podgląd logów usługi na żywo
journalctl -u gns3 -f