> ## Content Index
> Fetch the complete content index at: https://innasiec.pl/llms.txt
> Use this file to discover other available public pages before exploring further.

# Wprowadzenie do GIT - podstawy systemu kontroli wersji
- URL: https://innasiec.pl/git-dla-inzynierow-sieci-przewodnik-dla-poczatkujacych-po-kontroli-wersji/
- Published: 2025-04-18T05:46:04.000Z
- Updated: 2025-04-18T18:26:45.000Z
- Description: Git w sieciach komputerowych to kluczowe narzędzie do zarządzania konfiguracjami, śledzenia zmian i współpracy zespołowej. Pozwala na kontrolę wersji, rozwiązywanie konfliktów i automatyzację procesów, zwiększając bezpieczeństwo i efektywność zarządzania infrastrukturą sieciową.
- Author: Rafał Rudewicz
- Tags: NetDevOps, #toc, #syntax-highlight

Git to niezwykle istotne narzędzie w arsenale inżyniera sieci, ponieważ umożliwia efektywne zarządzanie wersjami konfiguracji, skryptów automatyzujących i dokumentacji.

**Dzięki Gitowi, możesz śledzić zmiany, współpracować nad projektami oraz przeprowadzać przeglądy kodu, co przekłada się na zwiększenie jakości i bezpieczeństwa zarządzanych systemów**. Oto kilka kluczowych aspektów i przykładów zastosowania Git w sieciach komputerowych:

1. **Śledzenie zmian**: Git pozwala na dokładne śledzenie każdej zmiany wprowadzonej do plików konfiguracyjnych lub skryptów. Dzięki temu można łatwo zidentyfikować, kto wprowadził daną zmianę, kiedy to zrobił i dlaczego.
2. **Współpraca**: Git umożliwia pracę zespołową, gdzie wielu inżynierów może pracować nad tym samym projektem jednocześnie. Ułatwia to dzielenie się wiedzą i doświadczeniem oraz przyspiesza proces rozwiązywania problemów.
3. **Peer review**: Dzięki funkcji pull requestów, inżynierowie mogą przeglądać i komentować zmiany wprowadzone przez innych członków zespołu, co zwiększa jakość kodu i pozwala na wczesne wykrywanie błędów.
4. **Kontrola zmian**: Git zapewnia możliwość cofnięcia się do poprzednich wersji plików, co jest szczególnie przydatne w przypadku błędów lub nieprzewidzianych problemów.

### Pierwsze kroki z Git

Zanim zagłębisz się w możliwości Git-a, upewnij się, że masz go zainstalowanego w swoim systemie. Pobierz odpowiednią wersję ze strony [git-scm.com](https://git-scm.com/?ref=innasiec.pl) i skonfiguruj podstawowe dane:

```git
git config --global user.name "Twoje Imię"
git config --global user.email "twoj.email@przyklad.com"
```

Te polecenie ustawią Twoją tożsamość w Git. Jest to ważne, ponieważ każda zmiana (commit) będzie podpisana Twoim imieniem. Ustawienie to jest globalne i wystarczy je wykonać raz na komputerze.

### Tworzenie i klonowanie repozytoriów

Repozytorium w Git to miejsce, w którym przechowywane są wszystkie pliki projektu oraz historia ich zmian. Repozytorium może być lokalne (na komputerze programisty) lub zdalne (na serwerze, np. GitHub, GitLab).

```git
git init
```

Inicjalizuje nowe repozytorium Git w bieżącym katalogu. Tworzy ukryty katalog `.git`, który zawiera całą historię projektu i ustawienia. Jest to pierwszy krok przy rozpoczynaniu nowego projektu z Git.

```git
git clone https://github.com/firma/network-configs.git
```

Tworzy lokalną kopię zdalnego repozytorium. Jest to jak pobranie całego projektu wraz z jego historią na Twój komputer. Używaj tego polecenia, gdy chcesz pracować nad istniejącym projektem.

### Dodawanie plików do repozytorium

Domyślnie w repozytorium Git nie są śledzone żadne pliki. Należy wskazać, które pliki w danym katalogu chcemy dołączyć do naszego repozytorium i śledzić w nich zmiany.

```git
git add konfiguracja-router01.txt
```

Polecenie `git add` służy do dodawania zmian w plikach do obszaru staging (indeksu) w systemie kontroli wersji Git. Oznacza to, że zmiany, które zostały wprowadzone w plikach, są przygotowywane do zapisania w kolejnym commicie. Polecenie to nie zapisuje jeszcze zmian w repozytorium, ale oznacza, które z nich mają być uwzględnione w przyszłym commitcie.

```git
git add .
```

Dodaje wszystkie zmienione pliki do poczekalni. Jest to wygodne, ale używaj ostrożnie - upewnij się, że wszystkie zmiany są rzeczywiście potrzebne. Zawsze sprawdź wcześniej `git status`, aby wiedzieć, co dodajesz.

```git
git commit -m "Dodano konfigurację routera 01"
```

Zapisuje zmiany w repozytorium wraz z opisowym komentarzem. Jest to jak robienie zdjęcia projektu w danym momencie - wszystkie dodane zmiany zostają trwale zapisane w historii. Dobry opis commita jest bardzo ważny dla późniejszego zrozumienia zmian.

```git
git push
```

Wysyła Twoje lokalne zmiany do zdalnego repozytorium. Udostępnia Twoje commity innym członkom zespołu. Upewnij się, że Twoje zmiany są dobrze przetestowane przed wykonaniem push.

```git
git pull
```

Pobiera zmiany ze zdalnego repozytorium i łączy je z Twoją lokalną kopią. Jest to jak synchronizacja Twojej pracy z pracą zespołu. Zawsze wykonuj pull przed rozpoczęciem pracy, aby mieć najnowszą wersję.

```git
git status
```

Pokazuje aktualny stan repozytorium. Wyświetla informacje o zmodyfikowanych plikach, nowych plikach i plikach przygotowanych do commita. To polecenie powinieneś używać bardzo często, aby wiedzieć, co się dzieje w Twoim repozytorium.

### Praca z gałęziami

Git umożliwia współpracę wielu osób nad jednym repozytorium, co jest kluczowe w projektach zespołowych. Aby uniknąć problemów związanych z równoczesną edycją tych samych plików przez różnych użytkowników, Git wprowadza pojęcie **gałęzi** (branchy).

Gdy chcesz wprowadzić zmiany w repozytorium, najpierw powinieneś utworzyć nową gałąź. Gałąź ta będzie kopią aktualnego stanu repozytorium, co pozwoli ci na modyfikacje bez wpływu na pracę innych.

```git
git checkout -b nowa-funkcja
```

Tworzy nową gałąź i od razu się na nią przełącza. Jest to skrót łączący dwa polecenia: `git branch nowa-funkcja` i `git checkout nowa-funkcja`. Używaj tego do rozpoczęcia pracy nad nową funkcjonalnością.

\--- title: Nowa gałąź w GIT --- gitGraph commit id: "Initial commit" commit id: "Add baseline config" branch nowa-funkcja commit id: "Add ACL for VTY" commit id: "Add ACL for SVI 500" 

Gdy Twoje zmiany są gotowe i przetestowane, możesz je zintegrować z główną gałęzią (najczęściej `main` lub `master`).

```git
git merge nowa-funkcja
```

\--- title: Wciąganie zmian z nowa-funkcja do main --- gitGraph commit id: "Initial commit" commit id: "Add baseline config" branch nowa-funkcja commit id: "Add ACL for VTY" commit id: "Add ACL for SVI 500" checkout main merge nowa-funkcja commit id: "Add new vrf RED" commit id: "Add vrf RED into BGP" 

Łączy zmiany z podanej gałęzi do aktualnej gałęzi. Przed wykonaniem merge upewnij się, że jesteś na właściwej gałęzi docelowej. W przypadku konfliktów Git poprosi Cię o ich rozwiązanie.

### Cofanie zmian i zarządzanie historią

Co w sytuacji, gdy zorientujemy się, że wprowadzone zmiany są nieprawidłowe? Polecenie `git revert` służy do przywracania zmian, które zostały wprowadzone w poprzednich commitach. Zamiast usuwać commit z historii, `git revert` tworzy nowy commit, który odwraca zmiany wprowadzone przez określony commit. To jest szczególnie przydatne, gdy chcesz anulować zmiany bez utraty historii projektu.

W dotychczasowych diagramach pokazywałem commity oraz ich wiadomości. Te wiadomości opisują wprowadzone zmiany.

Każdy commit ma unikalny identyfikator. Jest on alfanumeryczny i składa się z 40 znaków. Identyfikator powstaje za pomocą algorytmu haszującego SHA-1.

Praca z tak długim ciągiem znaków może być niewygodna. Dlatego Git umożliwia korzystanie ze skróconych wersji identyfikatorów. Można używać początkowych znaków, o ile są one unikatowe w repozytorium.

```git
git revert 6-d76a890
```

Tworzy nowy commit, który cofa zmiany wprowadzone przez commit o identyfikatorze d76a890\. Jest to bezpieczny sposób na anulowanie zmian, ponieważ nie usuwa historii. Użyj tego, gdy chcesz cofnąć zmiany, które zostały już udostępnione innym.

\--- title: Cofanie zmian z commita --- gitGraph commit commit branch nowa-funkcja commit commit checkout main merge nowa-funkcja commit commit id: "6-d76a890" commit id: "Reverse" type: REVERSE commit commit 

```git
git reset --hard HEAD~1
```

Cofa stan repozytorium do poprzedniego commita. Używaj ostrożnie, ponieważ usunie to commit z historii. Jest przydatne, gdy chcesz całkowicie usunąć ostatni commit i związane z nim zmiany.

### Rozwiązywanie konfliktów

Konflikty w Git występują, gdy dwie osoby zmodyfikowały ten sam fragment pliku i próbują scalić swoje zmiany. Git nie jest w stanie automatycznie zdecydować, która wersja jest prawidłowa, dlatego wymaga interwencji użytkownika.

Gdy występuje konflikt podczas mergowania lub rebasowania, Git oznacza konfliktujące miejsca w plikach:

```
<<<<<<< HEAD
Konfiguracja interfejsu GigabitEthernet0/1
description LAN
ip address 192.168.1.1 255.255.255.0
no shutdown
=======
Konfiguracja interfejsu GigabitEthernet0/1
description WAN Link
ip address 10.0.0.1 255.255.255.252
no shutdown
>>>>>>> nowa-funkcja
```

Aby rozwiązać konflikt:

1. Otwórz pliki z konfliktem i zdecyduj, które zmiany chcesz zachować.
2. Usuń znaczniki konfliktów (<<<<<<< HEAD, =======, >>>>>>> nowa-funkcja) i pozostaw tylko poprawną wersję.
3. Zapisz plik.
4. Dodaj rozwiązane pliki do staging area: `git add <nazwa-pliku>`.
5. Zakończ proces mergowania: `git commit`.

### Przydatne polecenia

**Śledzenie zmian w konfiguracji urządzeń**

```git
git diff konfiguracja-router01.txt
```

Pokazuje różnice między aktualnym stanem pliku a ostatnią zatwierdzoną wersją. Jest to przydatne do sprawdzenia, jakie dokładnie zmiany zostały wprowadzone. Możesz używać tego przed commitowaniem, aby upewnić się, że wszystkie zmiany są prawidłowe.

```git
git log --pretty=format:"%h - %an, %ar : %s" konfiguracja-router01.txt
```

Wyświetla historię zmian dla konkretnego pliku w bardziej czytelnym formacie. Pokazuje kto, kiedy i jakie zmiany wprowadził. Użyj tego, gdy chcesz sprawdzić historię zmian dla danego pliku konfiguracyjnego.

**Przechowywanie danych wrażliwych**

W przypadku konfiguracji urządzeń sieciowych często mamy do czynienia z wrażliwymi danymi, takimi jak hasła czy klucze. Nie powinny one być przechowywane w repozytorium Git.

Rozwiązaniem jest zastosowanie pliku `.gitignore`, który pozwala określić, które pliki mają być ignorowane przez Git:

```bash
# Plik .gitignore
credentials.txt
secrets/
*.key
```

Do przechowywania haseł i kluczy można wykorzystać narzędzia takie jak:

- Hashicorp Vault
- AWS Secrets Manager
- Ansible Vault

### **Konwencje commitów**

Stosowanie spójnych konwencji opisu commitów jest kluczowe w pracy zespołowej. Dobrze napisane commity ułatwią Ci przeglądanie historii, debugowanie problemów oraz automatyzację procesów CI/CD.

```
[TYP]: Krótki opis zmiany (max 50 znaków)

Długi opis zmiany, jeśli jest potrzebny. Wyjaśnij co i dlaczego,
a nie jak (kod to wyjaśnia). Może zawierać wiele akapitów.

Lokalizacja: DC-WARSZAWA
Urządzenia: CORE-RTR-01, CORE-RTR-02
Ticket: NETOPS-123
Testowane: Tak, w środowisku staging
```

Gdzie TYP może być jednym z:

- `CONF`: zmiany w konfiguracji urządzeń
- `DOC`: zmiany w dokumentacji
- `TEST`: dodanie lub modyfikacja testów
- `AUTO`: zmiany w skryptach automatyzujących

Więcej o tym jak pisać dobre komunikaty commitów możesz przeczytać w artykule:

[Jak pisać dobre komunikaty Git commit?Odkryj sekrety skutecznych wiadomości commit w Git! Dowiedz się, jak pisać jasne, zwięzłe komentarze, które pomogą Twojemu zespołowi śledzić zmiany i zarządzać projektami jak profesjonalista. Nie przegap tych ważnych wskazówek, które mogą odmienić Twoje podejście do pracy!![](https://innasiec.pl/content/images/icon/recreate-02-9.png)Inna SiećRafał Rudewicz![](https://innasiec.pl/content/images/thumbnail/jak-pisac-dobre-komunikaty-git.webp)](https://innasiec.pl/jak-pisac-dobre-komunikaty-git-commit/)

Git to potężne narzędzie, które znacząco usprawnia pracę. Pozwala na efektywne zarządzanie konfiguracjami, współpracę w zespole oraz automatyzację wdrażania zmian. Choć początkowe opanowanie podstawowych poleceń może wymagać pewnego wysiłku, korzyści z używania Git są nieocenione.

Zachęcam do eksperymentowania z Git i stopniowego włączania go do swojego warsztatu pracy. Rozpocznij od prostych operacji, takich jak śledzenie zmian w plikach konfiguracyjnych, a z czasem przejdź do bardziej zaawansowanych zastosowań, takich jak automatyzacja czy GitOps.