Software Überblick
ISO / OSI Modell
| Nr. | OSI Schicht | Einordnung | TCP/IP | Protokolle | Einheiten | Hardware |
|---|---|---|---|---|---|---|
| 7 | Anwendung | Anwendungsorientiert | Anwendung | DHCP | Daten | Gateway |
| (Application) | DNS | Proxy | ||||
| 6 | Darstellung | FTP | Layer 4-7 Switch | |||
| (Presentation) | HTTP | |||||
| 5 | Sitzung | MQTT | ||||
| (Session) | ||||||
| 4 | Transport | Transportorientiert | Transport | TCP | Segmente (TCP) | |
| (Transport) | UDP | Datagramme (UDP) | ||||
| 3 | Vermittlung | Internet | ICMP | Pakete | Router | |
| (Network) | IGMP | Layer-3 Switch | ||||
| IP | ||||||
| 2 | Sicherung | Netzzugriff | IEEE 802.3 Ethernet | Frames | Bridge | |
| (Data Link) | IEEE 802.11 WLAN | Access Point | ||||
| MAC | Layer-2 Switch | |||||
| 1 | Bitübertragung | 1000BASE-T | Bits, Symbole | Kabel | ||
| (Physical) | Token Ring | Repeater | ||||
| Hub |
1. Bitübertragungsschicht / Physical Layer (z.B.: Ethernet - 100BASE-T)
In dieser Schicht werden die mechanischen, elektrischen und physikalischen Eigenschaften definiert, um Bits über ein Transportmedium übertragen zu können. Durch die Verwendung verschiedener Modulationsverfahren können auch mehrere Bits pro Zustand in Symbolen codiert und übertragen werden.
2. Sicherungsschicht / Data Link Layer (z.B.: Ethernet - IEEE 802.3)
Diese Schicht übernimmt die Sicherstellung einer zuverlässigen und weitgehend fehlerfreien Übertragung. Meistens ist auch eine Zugriffsregelung auf das Übertragungsmedium (Media Access Control MAC), eine Datenflusskontrolle für die dynamische Steuerung der Geschwindigkeit, das Aufteilen des Datenstromes in Frames und das Hinzufügen von Prüfsummen für eine Fehlererkennung bzw. -korrektur inkludiert. Das wiederholte Senden verworfener Frames wird von höheren Schichten übernommen.
3. Vermittlungsschicht / Network Layer (z.B.: Internet Protocol)
Diese Schicht sorgt für die Vermittlung von Paketen über das gesamte Kommunikationsnetz. Bei der Vermittlung sind die Stauvermeidung (Congestion Avoidance), das Fragmentieren von Datenpaketen (Aufteilen der Pakete, falls die Größe die max. Übertragungseinheit der Netzwerkschnittstelle überschreitet), die Wegesuche (Routing) und das Bereitstellen netzwerkübergreifender Adressen inkludiert.
4. Transportschicht / Transport Layer (z.B.: TCP / UDP)
Die Aufgaben dieser Schicht ist das Segmentieren des Datenstromes (Segmentgröße wird vom Sender und Empfänger ausgehandelt), die Flusssteuerung bzw. Staukontrolle und gegebenenfalls das Sicherstellen einer fehlerfreien Übertragung (TCP mit garantierter Zustellung, UDP ohne). Die Adressierung innerhalb dieser Schicht erfolgt über Port-Nummern.
5. Sitzungsschicht / Session Layer (z.B.: FTP / HTTP / MQTT)
In dieser Schicht werden die logischen Verbindungen gesteuert und so für eine Prozesskommunikation zwischen zwei Systemen gesorgt. Somit können ausgefallene Transportverbindungen wieder synchronisiert werden, ohne bei der Übertragung von vorne beginnen zu müssen.
6. Darstellungsschicht / Presentation Layer (z.B.: FTP / HTTP / MQTT)
Diese Schicht sorgt für das Umsetzen von einer systemabhängigen Darstellung in eine unabhängige Form, sowie für die Datenkompression und Verschlüsselung. Damit wird ein syntaktisch korrekter Datenaustausch zwischen unterschiedlichen Systemen garantiert.
7. Anwendungsschicht / Application Layer
Diese Schicht stellt Funktionen für die Anwendung zur Verfügung und stellt die Verbindung zu den unteren Schichten her. Hier findet die Daten Ein- und Ausgabe für die Anwendung statt. Die Anwendung selbst ist kein Teil dieser Schicht.
IP Adressen
IPv4
4 Blöcke mit jeweils 8 Bit / 1 Dezimalzahl durch „.“ getrennt 192.168.0.10 Netznotation 192.168.0.0/24 entspricht 192.168.0.0 bis 192.168.0.255 Netzwerk Angabe 192.168.0.10/24 beinhaltet IPv4 Adresse 192.168.0.10 und Subnetzmaske 255.255.255.0 Die Subnetzmaske wird verwendet, um zu entscheiden, ob ein Paket an den Provider oder einen anderen Router im eigenen Netz oder überhaupt nicht weitergeleitet wird.
| 0.0.0.0/8 | Standard Route |
| 127.0.0.0/8 | Loopback Adressen |
| 10.0.0.0/8 | Link Local Adressen - Netzklasse A |
| 172.16.0.0/12 | Link Local Adressen - Netzklasse B |
| 192.168.0.0/16 | Link Local Adressen - Netzklasse C |
| 169.254.0.0/16 | Link Local Adressen, falls DHCP fehlgeschlagen ist |
IPv6
8 Blöcke mit jeweils 16 Bit / 4 Hexadezimalstellen durch „:“ getrennt 2001:0db8:85a3:08d3:0000:ffff:c0a8:000a Führende Nullen innerhalb eines Blockes dürfen weggelassen werden 2001:db8:85a3:8d3:0:ffff:c0a8:a Ein oder mehrere Blöcke mit Wert 0 dürfen vereinfacht mit „::“ dargestellt werden, aber maximal einmal 2001:db8:85a3:8d3::ffff:c0a8:a Für die letzten beiden Blöcke darf die herkömmliche dezimale Notation verwendet werden 2001:db8:85a3:8d3::ffff:192.168.0.10 Netznotation 2001:db8:85a3:8d3::/64 entspricht 2001:0db8:85a3:08d3:0000:0000:0000:0000 bis 2001:0db8:85a3:08d3:ffff:ffff:ffff:ffff Der Internet Service Provider ISP bekommt mit den ersten 32 Bit ein Netz zugewiesen 2001:db8::/32 Der ISP weist dem Endkunden ein Netz von typ. 2001:db8:85a3::/48 bis 2001:db8:85a3:8d3::/64 zu
| ::/128 bzw. 0:0:0:0:0:0:0:0/128 | nicht spezifizierte Adresse / Adresse falls noch nicht initialisiert | |||
| ::/0 bzw. 0:0:0:0:0:0:0:0/0 | Standard Route | |||
| ::1/128 bzw. 0:0:0:0:0:0:0:1/128 | Loopback Adresse (entspricht bei IPv4 127.0.0.1/32) | |||
| fe80::/64 | Link Local (Unicast) Adressen (LLA) | |||
| lokales Netz mit Hubs/Switches bis zum ersten Router, wird nicht weiter geroutet | ||||
| fc00::/7 | Unique Local (Unicast) Adressen (ULA) | |||
| fc00::/8 für global zugewiesene / zentral verwaltete Adressen | ||||
| fd00::/8 für lokal zugewiesene / verwaltete Adressen | ||||
| ff00::/8 | Multicast Adressen | |||
| nach ff folgen 4 Bits für Flags und 4 Bits für den Gültigkeitsbereich | ||||
| Flag-Kombinationen |
||||
| 0: | Permanent definierte wohlbekannte Multicast-Adressen | |||
| 1: | (T-Bit gesetzt) Transient (vorübergehend) oder dynamisch zugewiesene Multicast-Adressen | |||
| 3: | (P-Bit gesetzt, erzwingt T) Unicast-Prefix-based Multicast-Adressen | |||
| 7: | (R-Bit gesetzt, erzwingt P und T) Multicast-Adressen, welche die Adresse des Rendezvous-Points enthalten | |||
| Gültigkeitsbereiche |
||||
| 1: | interface-lokal – diese Pakete verlassen die Schnittstelle nicht (Loopback) | |||
| 2: | link-lokal – werden von Routern grundsätzlich nicht weitergeleitet und können deshalb das Subnetz nicht verlassen | |||
| 4: | admin-lokal – der kleinste Bereich, dessen Abgrenzung in den Routern speziell administriert werden muss | |||
| 5: | site-lokal – dürfen zwar geroutet werden, jedoch nicht von Border-Routern | |||
| 8: | organisations-lokal – die Pakete dürfen auch von Border-Routern weitergeleitet werden, bleiben jedoch „im Unternehmen“ | |||
| e: | globaler Multicast, der überallhin geroutet werden darf | |||
| 0, f: | reservierte Bereiche | |||
| die restlichen Bereiche sind nicht zugewiesen und dürfen von Administratoren benutzt werden, um weitere Multicast-Regionen zu definieren | ||||
| Beispiele für wohlbekannte Multicast-Adressen |
||||
| ff01::1, ff02::1: | All-Nodes Adressen, entspricht dem Broadcast in einem Bereich | |||
| ff01::2, ff02::2: | All-Routers Adressen, adressiert alle Router in einem Bereich | |||
| ff01::101, ff02::101 | All-NTP Adressen, adressiert alle Zeitserver | |||
| 0:0:0:0:0:ffff::/96 | IPv4 mapped IPv6 Adressen – letzten 32 Bit enthalten die IPv4 Adresse | |||
| 2000::/3 | IANA vergebene globale Unicast Adressen (GUA) – routbar, weltweit | |||
| 2001::/32 | Adressen für Tunnelmechanismus Teredo | |||
| 2001:db8::/32 | Adressen für Dokumentationszwecken | |||
Versionsverwaltung (SVN, GIT)
Damit man bei Software-Projekten die vergangenen Änderungen und die Übersicht nicht verliert, verwendet man gerne Versionsverwaltungssysteme wie Subversion oder Git. Bei der Verwendung solcher Systeme können sämtliche Änderungen am Source-Code nachverfolgt und auch verglichen werden. Des Weiteren können unterschiedliche Entwicklungspfade (z.B. unterschiedliche Versionen für unterschiedliche Betriebssysteme bzw. Hardware-Systeme) einfach verwaltet werden.
Das wichtigste bei der Verwendung von Subversion oder Git ist, dass beim Einpflegen eines neuen SW-Standes immer auch Kommentare eingetragen werden. Somit kann man Änderungen folgen, ohne gleich den Source Code durchsehen zu müssen. Damit Projekte mit mehreren Entwicklern tatsächlich übersichtlich bleiben, muss man sich zuvor gut überlegen, wie man die Versionsverwaltungs-Funktionen verwendet. D.h. für gewisse Vorgänge (Tagging, Branching, Submodule Handling) sollte es einen definierten Prozess geben.
Subversion
Bei Subversion (SVN) handelt es sich um ein zentrales Versionsverwaltungssystem. Jeder Benutzer arbeitet mit einer lokalen Kopie und muss sich beim Einpflegen von Änderungen mit dem Server verbinden. Ein lokales Einpflegen von Änderungen ist nicht möglich. Solange man offline arbeitet, gibt es keine Möglichkeit, Änderungen mit Kommentaren einzupflegen. Somit fehlt zu dieser Zeit auch die Möglichkeit bereits funktionierenden Code sicher abzulegen und gegebenenfalls wieder zurück zu holen.
Deutsch:
- zentrale Versionsverwaltung
- Einpflegen, … benötigt Verbindung zum Repository
- jeder Benutzer arbeitet mit einer Kopie vom Repository
- die History ist nur zentral verfügbar
- Verzweigen und Zusammenführen ist zeitaufwändiger
- Revisionsnr. wird für einen bestimmten Zustand des Repositorys vergeben, der sich über die Zeit nicht mehr verändert
- Inhalte werden in Dateien abgelegt
- Inhalt wird nicht gehashet um Datenfehler vorzubeugen
Englisch:
- centralized version control
- must be connected to commit, …
- each user has a copy of the repository
- local copy doesn’t contain the history
- branching and merging is time-consuming
- revision nr. is a snapshot of the repository at any given time
- content is stored within files
- doesn’t have hashed content
Weitere nützliche Subversion Informationen findet man unter:
Git
Bei Git handelt es sich um ein verteiltes Versionsverwaltungssystem. Die Benutzer arbeiten mit einer kompletten Kopie (Klon) des Repositories, History usw. mit eingeschlossen. Somit können Repository Änderungen auch lokal und offline erfolgen. Diese Möglichkeit erfordert dadurch eine unterschiedliche Arbeitsweise. Anstelle von den Subversion Basis-Kommandos Commit und Update, gibt es Commit (lokal), Push (remote) und Pull (remote).
Deutsch:
- verteilte Versionsverwaltung
- Einpflegen, … auch lokal/offline möglich
- jeder Benutzer arbeitet mit einem Klon des Repositorys
- die History ist auch offline verfügbar
- Verzweigen und Zusammenführen einfacher
- keine globale Revisionsnr. verfügbar
- Inhalte werden als Metadaten abgelegt
- Inhalte werden kryptographisch mit SHA-1 Checksumme versehen
Englisch:
- distributed version control
- can work locally/offline
- each user has a copy of the full repository
- local copy contains the complete repository, incl. the history
- easy to fork/branch and merge
- no global revision nr. available
- content is stored as metadata
- content is cryptographically check-summed using SHA-1 hash algorithm
Bei Git gibt es vier Arbeitsbereiche: die lokale Arbeitskopie, den Index Bereich für das nächste Commit, das lokale Repository und das remote Repository. Mit der Grafik unterhalb sieht man die unterschiedlichen Wirkungsbereiche der Befehle.
Für das Abzweigen innerhalb eines Projektes für zusätzliche Features, Bugfixing, … gibt es unterschiedliche Ansätze. Ein möglicher Ansatz ist git-flow (siehe Grafik unterhalb). Diese Methode ist aber bereits sehr komplex und erfordert viel Disziplin bei den Software-Entwicklern. Für viele kleine Projekte bzw. kleinere Entwicklungsteams reichen vereinfachte Methoden.
Für das lokale Versionieren kann Git folgendermaßen verwendet werden:
git init |
Anlegen eines Repositories im aktuellem Verzeichnis |
git add . |
Alles Hinzufügen mit Beachtung von .gitignore |
git status |
Status-Ausgabe des Repositories |
git commit -m 'message' |
Speichern der hinzugefügten Dateien im lokalem Repository |
| Nach Dateiänderungen | |
git add . |
Hinzufügen aller Änderungen für den nächsten Commit |
git add asdf.txt |
Hinzufügen einzelner Änderungen für den nächsten Commit |
git status |
Repository Status (Änderungen, Staged Dateien) |
git commit -m 'message' |
Speichern der Änderungen im lokalem Repository |
git commit -a -m 'message' |
Hinzufügen und Speichern aller Änderungen im lokalem Repository (inkl. gelöschter, exkl. hinzugef. Dateien) |
| Nachträgliches Verbinden mit einem Remote Server | |
git remote add origin https://gitlab.com/path/repo.git |
Hinzufügen eines Remote Servers als “origin” |
Für das Arbeiten mit einem Repository Server braucht man folgende Kommandos:
git clone https://user@gitlab.com/path/repo.git |
Klonen eines Repositories ins Verzeichnis “repo” (ins lokale Repository) |
git clone https://gitlab.com/path/repo.git ./proj |
Klonen eines Repositories ins Verzeichnis “proj” |
--branch <branch> |
Klonen eines bestimmten Branches |
-depth=1 |
Klonen mit Angabe der Tiefe (hier z.B. aktueller Commit) |
| Übernahme möglicher Remote Änderungen | |
git fetch |
Abrufen aller Änderungen des getrackten Branches des Remote Repositories |
git fetch --all |
Abrufen aller Änderungen aller Branches aller konfigurierten Remote Repositories |
git fetch <remote> |
Abrufen aller Änderungen aller Branches von einem bestimmten Remote Repository |
git fetch <remote> <branch> |
Abrufen aller Änderungen eines Branches von einem bestimmten Remote Repository |
git fetch https://user@gitlab.com/path/repository.git |
Abrufen aller Änderungen aller Branches des Remote Repositories |
origin |
Standard Remote Repository |
origin main |
Standard Main Branch des Standard Remote Repositories |
git pull --no-commit |
Übernehmen der Remote Änderungen des getrackten Branches in die lokale Kopie ohne Merge und Commit |
git pull |
Übernehmen der Remote Änderungen inklusive Merge und Commit |
git pull --rebase |
Übernehmen der Remote Änderungen inklusive Rebase und Commit |
git pull <remote> |
Übernehmen der Remote Änderungen von einem bestimmten Remote inklusive Merge und Commit |
git pull <remote> <branch> |
Übernehmen der Remote Änderungen von einem bestimmten Remote und Branch inklusive Merge und Commit |
| Branches verwalten (wechseln, erstellen oder löschen) | |
git branch |
Ausgabe aller lokalen Branches |
git branch -r |
Ausgabe aller Remote Branches |
git branch -a |
Ausgabe aller lokalen und Remote Branches |
git branch -d <branch> |
Löschen eines Branches (nur wenn er gemerged wurde) |
git branch -D <branch> |
Erzwingtes Löschen eines Branches |
git checkout <branch> |
Wechsel zu einem Branch |
git checkout -b <branch> |
Erstellen eines Branches, mit Wechsel dahin |
git branch <branch> |
Erstellen eines Branches, ohne Wechsel dahin |
| Nach Dateiänderungen | |
git add . |
Hinzufügen aller Änderungen für den nächsten Commit |
git add asdf.txt |
Hinzufügen einzelner Änderungen für den nächsten Commit |
git status |
Repository Status (Änderungen, Staged Dateien) |
git commit -m 'message' |
Speichern der Änderungen ins lokale Repository |
git commit -a -m 'message' |
Hinzufügen und speichern aller Änderungen ins lokale Repo (inkl. gelöschter, exkl. hinzugefügter Dateien) |
git push |
Übernehmen der lokalen Kopie in das Remote Repository |
git push <remote> <branch> |
Übernehmen der lokalen Kopie in das Remote Repository |
Weitere nützliche Git Informationen findet man unter: