IPv6 vs IPv4

Wstęp

IP wersja 6IPv6 to następca protokołu IPv4, zaprojektowany głównie po to, aby rozwiązać problem wyczerpywania się adresów IP.
Rozmiar adresówW IPv4 używa się adresów 32-bitowych, a w IPv6 adresy mają 128 bitów, co daje praktycznie niewyczerpalną pulę urządzeń możliwych do zaadresowania.
Format zapisu adresuAdres IPv6 zapisuje się w postaci ośmiu grup liczb szesnastkowych oddzielonych dwukropkami, np. 2001:0db8:85a3:0000:0000:8a2e:0370:7334.
Skracanie adresówIPv6 pozwala skracać zapis adresów poprzez usuwanie zer wiodących oraz zastępowanie jednego ciągu zer symbolem ::.
Powyższy adres wygląda wtedy tak: 2001:db8:85a3::8a2e:370:7334.
Bez NAT?W przeciwieństwie do IPv4, IPv6 został zaprojektowany z myślą o komunikacji end-to-end, dlatego NAT nie jest już wymaganym elementem typowej sieci.
SLAAC i DHCPv6IPv6 wprowadza mechanizm SLAAC (Stateless Address Autoconfiguration), dzięki któremu urządzenia mogą automatycznie generować własne adresy bez klasycznego DHCP. SLAAC nie zastępuje całkowicie DHCPv6
DHCPv6 dostarcza dodatkowe informacje, np. DNS.
Brak broadcastuW IPv6 nie występuje broadcast — zamiast niego używa się multicastu oraz anycastu, co upraszcza i ogranicza zbędny ruch w sieci.
Nagłówek IPv6Nagłówek pakietu IPv6 jest prostszy i bardziej przewidywalny niż w IPv4, co ułatwia wydajne przetwarzanie ruchu przez routery.
IPSecProtokół IPv6 wspiera IPSec jako integralny element architektury, choć w praktyce jego użycie nadal zależy od konfiguracji administratora.
Dual stackWspółczesny Internet działa w modelu dual stack, gdzie urządzenia i sieci obsługują jednocześnie IPv4 i IPv6, ponieważ pełna migracja nadal trwa.


IPv4 – adresy specjalne i pule

TypPrzykładowy adres (pełny zapis)Opis
Unicast publiczny8.8.8.8
93.184.216.34
1.1.1.1
Publiczne adresy routowalne w Internecie. Każdy adres identyfikuje pojedynczy host globalnie.
Unicast prywatny
(10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16)
10.0.0.1
172.16.5.10
192.168.1.1
Prywatne adresy używane w sieciach lokalnych (LAN). Nie są routowane w Internecie i wymagają NAT do komunikacji z siecią publiczną.
Loopback (127.0.0.0/8)127.0.0.1
127.0.0.2
127.255.255.255
Adresy lokalnego hosta używane do testowania stosu sieciowego TCP/IP. Ruch nie opuszcza urządzenia.
Link-local (APIPA) (169.254.0.0/16)169.254.1.1
169.254.10.20
169.254.255.255
Automatycznie przypisywane, gdy brak serwera DHCP. Działają tylko w lokalnym segmencie sieci.
Broadcast sieciowy192.168.1.255
10.0.0.255
172.16.255.255
Adres wykorzystywany do wysyłania danych do wszystkich hostów w konkretnej podsieci. Zależy od maski.
Broadcast ogólny255.255.255.255Wysyłanie pakietu do wszystkich hostów w lokalnej sieci (ograniczony broadcast).
Dokumentacyjne (192.0.2.0/24, 198.51.100.0/24, 203.0.113.0/24)192.0.2.1
198.51.100.10
203.0.113.5
Adresy przeznaczone do dokumentacji i przykładów. Nie są routowane w Internecie.


IPv6 – adresy specjalne i pule

Typ + przykładowy adres (pełny zapis)Opis
Unicast globalny (2000::/3) 2001:0db8:85a3:0000:0000:8a2e:0370:7334 3fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff 2000:0000:0000:0000:0000:0000:0000:0001Publiczne adresy routowalne w Internecie. Zapis „/3” oznacza długość prefiksu, czyli że pierwsze 3 bity adresu IPv6 są stałe i identyfikują ten zakres. Obejmuje to wszystkie adresy od 2000:: do 3fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff. Są odpowiednikiem publicznych adresów IPv4.
Unicast prywatny ULA (fc00::/7, praktycznie fd00::/8) fd12:3456:789a:0000:0000:0000:0000:0001 fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffffPrywatne adresy używane w sieciach lokalnych i organizacyjnych. Nie są routowane w Internecie. W praktyce stosuje się zakres fd00::/8, analogiczny do prywatnych zakresów IPv4 (np. 10.0.0.0/8).
Link-local (fe80::/10) fe80:0000:0000:0000:a00:27ff:fe4e:66a1 febf:ffff:ffff:ffff:ffff:ffff:ffff:ffffAdresy automatycznie przypisywane interfejsom IPv6. Działają wyłącznie w jednym segmencie sieci L2 i nie są routowane przez routery. Używane m.in. przez Neighbor Discovery i komunikację z bramą domyślną.
Multicast (ff00::/8) ff02:0000:0000:0000:0000:0000:0000:0001 ff02:0000:0000:0000:0000:0000:0000:0002Adresy grupowe „jeden do wielu”. IPv6 nie używa broadcastu — jego rolę przejął multicast. Przykładowo ff02::1 oznacza wszystkie hosty w sieci lokalnej, a ff02::2 wszystkie routery.
Loopback (::1/128) 0000:0000:0000:0000:0000:0000:0000:0001Adres pętli zwrotnej lokalnego hosta (odpowiednik 127.0.0.1). Ruch na ten adres nie wychodzi poza urządzenie i jest przetwarzany lokalnie.
Unspecified (::/128) 0000:0000:0000:0000:0000:0000:0000:0000Oznacza brak przypisanego adresu IPv6. Używany podczas startu systemu lub autokonfiguracji. Nie może być używany jako adres źródłowy ani docelowy w normalnym ruchu.
IPv4-mapped IPv6 (::ffff:0:0/96) 0000:0000:0000:0000:0000:ffff:192.168.1.1Mechanizm reprezentacji IPv4 w przestrzeni IPv6, używany głównie wewnętrznie przez systemy operacyjne i API sieciowe w trybie dual-stack.
NAT64 (64:ff9b::/96) 0064:ff9b:0000:0000:0000:0000:c000:0201Prefiks używany w translacji NAT64, umożliwiającej komunikację IPv6 → IPv4. Ostatnie 32 bity zawierają zakodowany adres IPv4.
Dokumentacyjne (2001:db8::/32) 2001:0db8:0000:0000:0000:0000:0000:0001Zakres przeznaczony do dokumentacji i przykładów. Nie jest routowany w Internecie i nie powinien być używany w produkcji.

Quest: Aplikacja z synchronizacją

Zadanie polega na przygotowaniu aplikacji webowej. Funkcjonalność aplikacji ma zostać zaprojektowana samodzielnie, najlepiej tak by realizowała własne potrzeby twórcy aplikacji. Może to być na przykład:

  • Aplikacja „Zakupy rodzinne”
  • TaskFlow — lista zadań
  • Notes / Wiki klasowe
  • Dziennik treningów / nawyków
  • Magazyn sprzętu

Ocenie podlegać będzie samodzielna realizacja projektu, w szczególności systematyczny rozwój aplikacji udokumentowany historią repozytorium Git (commity, zakres i chronologia zmian). Na potrzeby oceny należy przygotować działający build aplikacji hostowany na publicznie dostępnym serwerze oraz udostępnić link do repozytorium Git zawierającego kompletny kod źródłowy projektu wraz z historią zmian umożliwiającą weryfikację indywidualnego wkładu i procesu rozwoju aplikacji.

Frontend (React)

  • React + Vite
  • useState, useEffect, useContext
  • podział na komponenty
  • formularze kontrolowane
  • komunikacja z API (fetch lub axios)
  • mile widziany routing (organizacji aplikacji, podziału na widoki, sensowny URL, prosta ale porządna nawigacja)
  • mile widziana autoryzacja JWT

Offline

  • przechowywanie danych lokalnie: IndexedDB lub localStorage (ewentualnie plik)
  • wbudowane w przeglądarkę wykrywanie offline/online:navigator.onLine
  • synchronizacja po odzyskaniu internetu

Synchronizacja

  • lokalna kopia danych
  • flaga synced
  • endpoint /sync (wysyłanie wszystkich lokalnych danych, albo wszystkich zmian)

Backend

  • Opcja PHP: PHP 8+, REST API, JSON, PDO, MySQL
  • Opcja Node: Express, websockety, MySQL2 lub Prisma

Przykładowe minimalne endpointy API

GET /items
POST /items
PUT /items/:id
DELETE /items/:id
POST /sync

Algorytm synchronizacji (prosty)

  1. zapis lokalny natychmiast
  2. rekord dostaje synced: false
  3. po internecie:
    • wysłanie zmian
    • backend aktualizuje MySQL
    • frontend ustawia synced: true

miniQuest: MySQL + PHP – podstawy

Uruchom, zrozum, ulepsz…

connection.php

<?php
$host = "localhost";
$user = "root";
$password = "";
$database = "testdb";

$conn = new mysqli($host, $user, $password, $database);

if ($conn->connect_error) {
    die("Błąd połączenia: " . $conn->connect_error);
}

$conn->set_charset("utf8");
?>

install.php

<?php

$host = "localhost";
$user = "root";
$password = "";

$conn = new mysqli($host, $user, $password);

if ($conn->connect_error) {
    die("Błąd połączenia: " . $conn->connect_error);
}

$sql = "CREATE DATABASE IF NOT EXISTS testdb";
$conn->query($sql);

$conn->select_db("testdb");

$sql = "DROP TABLE IF EXISTS osoby";
$conn->query($sql);

$sql = "CREATE TABLE osoby (
    id INT AUTO_INCREMENT PRIMARY KEY,
    imie VARCHAR(50),
    nazwisko VARCHAR(50)
)";

$conn->query($sql);

$osoby = [
    ['Jan', 'Kowalski'],
    ['Anna', 'Nowak'],
    ['Piotr', 'Wiśniewski'],
    ['Maria', 'Wójcik'],
    ['Tomasz', 'Kowalczyk'],
    ['Katarzyna', 'Kamińska'],
    ['Paweł', 'Lewandowski'],
    ['Agnieszka', 'Zielińska'],
    ['Michał', 'Szymański'],
    ['Barbara', 'Woźniak'],
    ['Jakub', 'Dąbrowski'],
    ['Ewa', 'Kozłowska'],
    ['Adam', 'Jankowski'],
    ['Monika', 'Mazur'],
    ['Krzysztof', 'Krawczyk'],
    ['Joanna', 'Piotrowska'],
    ['Mateusz', 'Grabowski'],
    ['Natalia', 'Pawłowska'],
    ['Damian', 'Michalski'],
    ['Karolina', 'Król']
];

foreach ($osoby as $o) {
    $imie = $o[0];
    $nazwisko = $o[1];

    $sql = "INSERT INTO osoby (imie, nazwisko)
            VALUES ('$imie', '$nazwisko')";

    $conn->query($sql);
}

echo "Baza i tabela zostały utworzone.";

$conn->close();

?>

pokaz1.php

<?php
include 'connection.php';
$sql = "SELECT * FROM osoby LIMIT 1";
$result = $conn->query($sql);
$row = $result->fetch_assoc();
echo $row['id'];
$conn->close();
?>

pokaz2.php

<?php

include 'connection.php';
$sql = "SELECT * FROM osoby";
$result = $conn->query($sql);

while ($row = $result->fetch_assoc()) {

    echo "ID: " . $row['id'] . "<br>";
    echo "Imię: " . $row['imie'] . "<br>";
    echo "Nazwisko: " . $row['nazwisko'] . "<br>";
    echo "<hr>";
}

$conn->close();

?>

delete1.php

<?php
include 'connection.php';
$sql = "DELETE FROM osoby WHERE id = 1";

if ($conn->query($sql) === TRUE) {
    echo "Rekord usunięty.";
} else {
    echo "Błąd: " . $conn->error;
}

$conn->close();

?>

update1.php

<?php

include 'connection.php';

$sql = "UPDATE osoby
        SET imie = 'Andrzej',
            nazwisko = 'Nowicki'
        WHERE id = 2";

if ($conn->query($sql) === TRUE) {
    echo "Rekord został zaktualizowany.";
} else {
    echo "Błąd: " . $conn->error;
}

$conn->close();

?>

dodaj.php

<?php

include 'connection.php';

$sql = "INSERT INTO osoby (imie, nazwisko)
        VALUES ('Sebastian', 'Lis')";

if ($conn->query($sql) === TRUE) {
    echo "Dodano rekord.";
} else {
    echo "Błąd: " . $conn->error;
}

$conn->close();

?>

Quest: Git i GitHub

Git to system kontroli wersji, który umożliwia śledzenie zmian w kodzie, ułatwiając współpracę w zespołach programistycznych oraz zarządzanie różnymi wersjami projektu. Działa lokalnie na komputerze i pozwala między innymi na łatwe odzyskiwanie wcześniejszych wersji kodu.

GitHub to platforma do hostowania zdalnych repozytoriów Git, która umożliwia programistom współpracę, przeglądanie kodu i zarządzanie projektami w chmurze. Alternatywami dla GitHub są m.in. GitLab, Bitbucket czy SourceForge.

Podstawowe pojęcia

Repository (repozytorium)miejsce, gdzie trzymany jest cały projekt. To „folder + historia zmian”. zawiera pliki projektu, zapisuje wszystkie zmiany w czasie, można go skopiować i pracować lokalnie
Clone (klonowanie)zabranie projektu na swój komputer. robisz pełną kopię repozytorium, masz wszystko: kod + historia, możesz pracować bez internetu
Branch (gałąź)równoległa wersja projektu do pracy bez psucia głównej. jak „osobny tor pracy”, można eksperymentować, główny projekt (main/master) zostaje bezpieczny
Commitzapis „checkpointu” zmian. robisz zapis postępu pracy, każdy commit to mały krok w historii, można cofnąć się do wcześniejszych stanów
Mergepołączenie dwóch wersji pracy. np. łączysz branch z głównym projektem, wprowadzasz zmiany do wspólnej wersji, czasem trzeba rozwiązać konflikty
Pull request (PR)propozycja zmian do projektu. „proszę, sprawdź moje zmiany i zaakceptuj”, miejsce do dyskusji i przeglądu kodu, standard pracy zespołowej
Forkskopiowanie czyjegoś projektu na własne konto. robisz „własną wersję cudzej pracy”, możesz ją modyfikować bez wpływu na oryginał, często używane w open-source
Pullpobranie najnowszych zmian z serwera. synchronizujesz swój lokalny projekt, dostajesz to, co zmienili inni

Jak to się łączy

  • repozytorium = projekt
  • clone = zabierasz projekt na komputer
  • branch = robisz swoją wersję roboczą
  • commit = zapisujesz postępy
  • pull request = prosisz o włączenie zmian
  • merge = łączenie zmian
  • fork = kopiujesz projekt dla siebie
  • pull = aktualizujesz się

Szybki start

Najpierw zainstaluj Git na komputerze: git-scm.com.

Wszystkie typowe funkcje można łatwo wyklikać, ale warto przynajmniej przeczytać jakie polecenia są wykonywane w tle w czasie klikania. Na początek wystarczy rozumieć to co w filmie i umieć wyklikać to co poniżej.

Jeśli chcesz używać poleceń – wykonuj je w wierszu poleceń swojego systemu (cmd, terminal) lub w wierszu poleceń swojego edytora kodu. Na początek potrzebna jest minimalna konfiguracja:

git config --global user.email "adres@poczty.pl"<br>
git config --global user.name "piotrek"<br>

Przykładowe polecenia GIT (jeśli ktoś nie chce klikać)

git init                 # Inicjalizuje nowe repozytorium
git clone <url>          # Klonuje zdalne repozytorium
git status               # Pokazuje stan plików
git add <plik>           # Dodaje plik do staging area
git add .                # Dodaje wszystkie zmienione pliki
git commit -m "wiadomość" # Zapisuje zmiany z komentarzem
git push                 # Wysyła commity do zdalnego repo
git pull                 # Pobiera i scala zmiany ze zdalnego repo
git branch               # Wyświetla listę gałęzi
git branch <nazwa>       # Tworzy nową gałąź
git checkout <gałąź>     # Przełącza na inną gałąź
git merge <gałąź>        # Scala gałąź z obecną
git log                  # Pokazuje historię commitów
git diff                 # Pokazuje niezapisane zmiany
git reset <plik>         # Usuwa plik ze staging area
git rm <plik>            # Usuwa plik i dodaje zmianę do staging
git stash                # Tymczasowo zapisuje niezacommitowane zmiany
git remote -v            # Pokazuje zdalne repozytoria

Zadanie

  • Wybierz prosty projekt z kilkoma plikami napisanymi w dowolnym języku.
  • Zainicjuj folder projektu w git.
  • Dodaj pliki.
  • Utwórz startowy commit. Pamiętaj o sensownym opisie.
  • Wprowadź zmiany w kodzie.
  • Utwórz kolejny commit. Pamiętaj o sensownym opisie.
  • Dodaj nowy plik do projektu i znów utwórz nowy commit. Pamiętaj o sensownym opisie.
  • Utwórz zdalne repozytorium (np. na GitHubie) i połącz je z lokalnym repozytorium.
  • Wprowadź zmiany w kodzie.
  • Utwórz kolejny commit. Pamiętaj o sensownym opisie.
  • Zsynchronizuj zdalne i lokalne repozytorium.
  • Ustaw repozytorium zdalne jako publiczne i wyślij mi linka
    Teraz możesz używać swojego konta na GitHubie jako quasi-bloga : )