====== Woche 2 - Microsoft Windows Server Kurs ======

  * [[GFN Sysadmin Kurs]]
    * [[Microsoft Windows Server Kurs]]
      * [[Woche 1 - Microsoft Windows Server Kurs]]
      * [[Woche 2 - Microsoft Windows Server Kurs]]
      * [[Woche 3 - Microsoft Windows Server Kurs]]
      * [[Woche 4 - Microsoft Windows Server Kurs]]
      * [[Woche 5 - Microsoft Windows Server Kurs]]
      * [[Woche 6 - Microsoft Windows Server Kurs]]
      * [[Woche 7 - Microsoft Windows Server Kurs]]
      * [[Woche 8 - Microsoft Windows Server Kurs]]


  * [[Moegliche Pruefungsfragen - Microsoft Windows Server Kurs]]


===== Tag 1: 17.02.2025 Montag =====


  * Kapitel 9. Skripting, Functions, Filter
    * Agenda
      * ...

  * Get-PSDrive
    * Laufwerk "Function"


  * Function
    * Liste von existierenden PowerShell-Befehlen mit einem Namen versehen (=Funktionsname), die dann in der Eingabeaufforderung ausgeführt werden kann
    * Functions können über Parameter verfügen
    * Functions sind ein Teil des Skriptings

<code>
# gibt eine Liste der Funtionen, Aliases, Cmdlets etc.
Get-Command
</code>


<code>
# Funktion definieren
Function <FunctionName>
{
  <Anweisungsblock>
  
}
</code>

<code>
# Funktion aufrufen
<FunctionName> [-Parameter1 [Wert1]] [-ParameterN [WertN]] 
</code>

  * Beispiel:
<code>
# 
Function Get-DiskDrive
{
  Get-PSDrive -PSProvider FileSystem
}
</code>
  * dann Skript speichern z.B. unter "MeineSkripte\MeineFunktionen.ps1"

  * die Skript-Datei MUSS ausgeführt werden, damit die dort definierten Funktionen in der aktuellen Session verfügbar werden

<code>
> MeineSkripte\MeineFunktionen.ps1
> # ab jetzt sind alle dort definierten Functions verfügbar
</code>

  * eine Ausführung von Skripten ist aber standardmäßig verboten (Ausnahme "Administrator"?)
<code>
# Abfragen (auf der Konsole) ob eine Ausführung erlaubt ist:
Get-ExecutionPolicy
# Setzen:
Set-ExecutionPolicy -ExecutionPolicy <PolicyName>
# Es gibt RemoteSigned / Unrestricted / AllSigned ...
</code>

  * bei der Ausführung MUSS der Pfad angegeben werden (sowie DOT-Sourcing -> MUSS)
<code>
. .\MeineFunktionen.ps1
</code>

  * Funktionen mit Parametern erstellen
<code>
# klassisch:
Function <Name>
{
  Param ($Parameter1[, $ParameterN])
  
  <Anweisungsblock>
}

# Neu (funktioniert nur bei Functions aber nicht bei Skriptenparametern):
Function <Name> [($Parameter1[, $ParameterN])] 
{
  
  <Anweisungsblock>
}
</code>

  * Beispiel
<code>
Function Get-LargeFiles ($Length)
{
  Get-ChildItem C:\Windows | Where-Object {$_.Length -ge $Length}  
}

# Mit Werten vorbelegen
Function Get-LargeFiles ($Location="C:\Windows", $Length=200)
{
  Get-ChildItem $Location | Where-Object {$_.Length -ge $Length}  
}
</code>

  * Zeilen trennen mit Backticks (ab PowerShell 5.0, kann man auch ohne Backticks)
<code>
Function Get-MyProcess ($Length)
{
  Get-Process -Name s* | `
  Select -Property ID, ProcessName, CPU | `
  Sort -Property CPU -Descending
}
</code>

  * Switch-Parameter 
    * Parameter ohne Wert
    * wenn vorhanden = TRUE
<code PowerShell>
Function Test-Switch ([switch]$AnAus)
{
  if($AnAus) {
    # ...
  }
  else {
    # ...
  }
}
</code>

  * Beispiel

<code PowerShell>
Function Get-LargeFiles ($groesse, [switch]$sortieren)
{
  $ausgabe = Get-ChildItem -Path C:\Windows -File | Where { $_.Length -ge $groesse}
  if($sortieren) {
    $ausgabe | Sort -Property Length
  }
  else {
    $ausgabe
  }
}
</code>

  * Objekte über Pipeline an **Funktionen** übergeben

<code PowerShell>
Function <Name> 
{
  Begin
  {
    # Anweisungsblock, der am Anfang ausgeführt wird
  }
  Process
  {
    # Anweisungsblock, der mit jedem Element ausgeführt wird
  }
  End
  {
    # Anweisungsblock, der am Ende ausgeführt wird
  }
}
</code>

  * Beispiel

<code PowerShell>
Function Get_Pipe1
{
  Begin
  {
    # Anweisungsblock, der am Anfang ausgeführt wird
    Write-Host "Pipeline Funktion gestartet"
  }
  Process
  {
    # Anweisungsblock, der mit jedem Element ausgeführt wird
    Write-Host "Wert des aktuellen Objektes $_."
  }
  End
  {
    # Anweisungsblock, der am Ende ausgeführt wird
    Write-Host "Pipeline Funktion zu Ende ausgeführt"
  }
}

# Aufruf:
1,2,3 | Get_Pipe1
</code>


  * Objekte kann man auch über Pipeline an **Skripte** übergeben

<code PowerShell>
  Begin
  {
    # Anweisungsblock, der am Anfang ausgeführt wird
    Write-Host "Pipeline Funktion gestartet"
  }
  Process
  {
    # Anweisungsblock, der mit jedem Element ausgeführt wird
    Write-Host "Wert des aktuellen Objektes $_."
  }
  End
  {
    # Anweisungsblock, der am Ende ausgeführt wird
    Write-Host "Pipeline Funktion zu Ende ausgeführt"
  }
  
  # Aufruf (jede Datei/Directory in C:\Windows wird an das Skript myPipeScript.ps1 übergeben)
  Get-ChildItem C:\Windows | .\myPipeScript.ps1
</code>


  * "Dokumentationstags"

<code PowerShell>
<#
.SYNOPSIS
Kurzbeschreibung...  

.DESCRIPTION
Ausführliche Beschreibung...  

.PARAMETER
Beschreibung Parameter 1...  

.PARAMETER
Beschreibung Parameter 2...  

.EXAMPLE
Beispiel 1...  

.EXAMPLE
Beispiel 2...  

.NOTES
Notizen...  

.LINK
...  

#>
</code>


  * Da die Funktionen auf dem virtuelle Laufwerk ''Function:'' sind:
    * Auflisten aller Funktionen kann man machen mit:
      * ''Get-ChildItem Function:''
    * ...
      * ''...''
    * Löschen
      * ''Remove-Item ...''


  * Kapitel 7. Profile
    * Thema "Profile" hat man zurückgestellt, da sie besser NACH den "Funktionen" passt

  * Profil als "Gedächtnis" der PowerShell
    * Eigene Aliase
    * Arbeitsumgebung (Farben etc...)
    * ...

  * 2 getrennte Profile
    * "normale" PowerShell
    * ISE

  * $profile
    * gibt den Pfad zu der aktuellen  Profil-Datei
    * Diese Datei wird bei jedem Start von PowerShell ausgeführt (so was wie "autoexec.bat")

  * ''$HOME\Documents\WindowsPowerShell\Microsoft.PowerShell_profile.ps1'' 
    * für "normale" PowerShell Konsole

  * ''$HOME\Documents\WindowsPowerShell\Microsoft.PowerShellISE_profile.ps1''

  * Man kann dort auch eigene Skripte laden (über DOT-Skripting)
    * ''. C:\MeineSkripte\MeineFunktionen.ps1''
==== Übung 9.14 (Seite 133)====

<code PowerShell>
Function Get-MyMessage
{
  Write-Host "Hier sind meine Funktionen gespeichert."
}

# Fügen Sie Ihrem Skript eine neue Funktion Get-MyProcess hinzu, die Prozesse auf Ihrem lokalen Rechner unter folgenden Bedingungen anzeigt:
#  Die anzuzeigenden Prozesse beginnen mit dem Buchstaben s.
#  Die Spalten ID, ProcessName und CPU sollen angezeigt werden.
#  Die Anzeige soll absteigend nach der Eigenschaft CPU sortiert werden.
# Speichern Sie Ihr Skript, führen Sie es erneut aus und testen Sie die Funktion.

Function Get-MyProcess
{
  Get-Process -Name s* | Select-Object ID, ProcessName, CPU | Sort-Object CPU -Descending
}

# Kopieren Sie die Funktion Get-MyProcess und fügen Sie sie unter dem Namen Get-MyProcess2
# in Ihr Skript ein. Wandeln Sie die Funktion wie folgt ab:
#  Die Funktion soll einen Parameter $FilterName akzeptieren, der bestimmt, welche Prozesse angezeigt werden. 
# Standardwert: Es sollen Prozesse angezeigt werden, deren Name mit dem Buchstaben s
# beginnt.
#  Über einen Switch-Parameter $Liste soll gesteuert werden, die Ausgabe als Liste zu sehen
# (Format-List) und nicht als Tabelle.
# Speichern Sie Ihr Skript, führen Sie es erneut aus und testen Sie die neue Funktion

Function Get-MyProcess2 ($FilterName="s", [switch] $Liste)
{
  $ausgabe =  Get-Process -Name "$FilterName*" | Select-Object ID, ProcessName, CPU | Sort-Object CPU -Descending
  if($Liste) {
    $ausgabe = $ausgabe | Format-List  
  }
  
  $ausgabe
}

</code> 

===== Tag 2: 18.02.2025 Dienstag =====

  * AM WICHTIGSTEN: **//__Gijaskin Geburtstag!!!__//** :)

Und dann:

  * Benutzerverwaltung geschieht in SAM (=Security Account Manager)
    * GUI davon :
      * "Computerverwaltung" (Rechts auf "Windows"-Symbol in der Taskleiste klicken)
      * System / Lokale Benutzer und Gruppen / Benutzer
        * Einen Benutzer anschauen (e.g. "v.kalaschnikow")
      * Um einen neuen Benutzer anlegen:
        * "Benutzer" mit rechts anklicken
          * "Neuer Benutzer"

  * In der PowerShell einen Benutzer anschauen mit Cmdlet ''Get-LocalUser''
    * => dann werden nur die wichtigsten Eigenschaften angezeigt
    * Alle verfügbaren Eigenschaften anzeigen:
      * ''Get-LocalUser | Get-Member''

  * In der PowerShell einen neuen Benutzer anlegen mit Cmdlet ''New-LocalUser''
    * Pflicht:
      * Name
      * Kennwort
  
  * Debugging Modus in der PowerShell ISE:
    * Skript muss gespeichert werden
    * Menü "Debuggen"
    * F9 - Breakpoint toggeln
    * F11 - Einzelschritt


  * Wir starten mit "Windows Server Verwaltung" (=>Thema "PowerShell" erstmal pausieren)
    * Buch von Nicole Laue verwenden
    * Wir fangen mit dem Kapitel 7 an: "Vom Einzelrechner zum Netzwerk: Grundlagen"

  * TCP/IP in der Praxis
    * Agenda
      * Allgemeine Netzwerkfunktionen
      * IP-Adressklassen
      * Multicasts
      * Private IP-Adressen
      * Gültige und ungültige individuellen IP-Adressen
        * => Übung (WICHTIG! evtl prüfungsrelvant)
      * Subnetting und Subnetzmasken
        * Adress-Segmentierung
      * Bestimmen der Anzahl der Subnetze
      * Bestimmen der Anzahl der Hosts pro Subnetz
      * Tools
      * Supernetting
      * Übungen

  * Allgemeine Netzwerkfunktionen
    * Vom Einzelrechner zum Netzwerk
      * Benutzer / Drucker / Scanner etc
        * geht lokal auf EINEM Einzelrechner
        * besser ist: GEMEINSAM Ressourcen nutzen
        * => Netzwerk notwendig

  * Richtlinien festlegen / Protokolle
    * Wer sendet
    * Was sendet
    * Wie die Daten aussehen
    * ...

  * Unicast
    * Kommunikation zwischen 2 definierten Punkten

  * Broadcast
    * Rundsendung ohne eine definierte Zieladresse

  * Multicast
    * senden an eine zuvor definierte Multicast-Gruppe
    * Beispiel :
      * Updates verteilen

  * Switches
    * "Verteiler", die angeschlossene Systeme einzeln erreichen können
    * 2 Arten
      * Hubs
        * haben keine "Verstärker"
      * Switches
        * haben "Verstärker"
    * heutzutage werden kaum Hubs verwendet

  * MAC-Adresse (Media Access Control)
    * eindeutig weltweit
    * "eingebrannt" in die Netzwerkkarte
    * 6 Hex-Doubletten
      * Bsp:
        * 00-02-B3-1A-A4-DC
      * die ersten 3 Doubletten: Kennung vom Hersteller

  * Netzwerkübertragung
    * physikalische Übertragung
      * CSMA/CD = Carrier Sense Multiple Access / Collision Detection
        * (N.B. irrelevant für die Prüfung)
    * logische Übertragung
      * TCP/IP Protokoll

  * TCP/IP ISO/OSI Modell
    * 7 Schichten
      * 7. Applicaiton Layer
      * 6. Presentation Layer
      * 5. Session Layer
      * 4. Transport Layer
      * 3. Network Layer
      * 2. Data Link Layer
      * 1. Physical Layer

  * TCP/IP 
    * Familie von Protokollen
      * SMTP, FTP, HTTP, HTTPS, SNMP ...
    * Ursprünglich 18, momentan ca. 50

  * ARP = Address Resolution Protocol
    * ARP - Request
      * "Ich bin <MyIP> mit MAC <MyMAC> und ich will mit <ZielIP> kommunizieren"
      * Wird über Broadcast gesendet
        * da Broadcast aufwendig ist, muss es so weit möglich reduziert werden
    * ARP-Response
      * wird vom angefragten System beantwortet
      * "Ich bin <IP> mit <MAC>"
      * Dann wird IP mit der MAC im IP-Cache vom Anfrager gespeichert
        * IP-Cache wird nach einer gewissen Zeit gelöscht (normalerweise ca. 1 Std)


  * Kapitel 8. IP-Adressierung

  * IP-Adresse
    * 4 Zahlen durch Kommata getrennt
      * Werte 0-255
    * Adressbereich (theoretisch)
      * von 0.0.0.0
      * bis 255.255.255.255

  * IP Adressklassen nach RFC 791
    * Klasse A
      * von 0.0.0.0 bis 127.255.255.255
      * Subnetzmaske 255.0.0.0
      * Startet mit 0 (binär)
      * 1 Byte - Netz Anteil
    * Klasse B
      * von 128.0.0.0 bis 191.255.255.255
      * Subnetzmaske 255.255.0.0
      * Startet mit 10 (binär)
      * 2 Bytes - Netz Anteil
    * Klasse C
      * von 192.0.0.0 bis 223.255.255.255
      * Subnetzmaske 255.255.255.0
      * Startet mit 110 (binär)
      * 3 Bytes - Netz Anteil
    * Klasse D
      * von 224.0.0.0 bis ...
      * Subnetzmaske x.x.x.x
      * Startet mit 1110 (binär) 
      * 2 Bytes - Netz Anteil
      * reserviert für Multicast
    * Klasse E
      * von 240.0.0.0 bis ...
      * Subnetzmaske x.x.x.x
      * Startet mit 1111 (binär) 
      * reserviert für Entwicklung, Forschung etc.

  * A,B,C Klassen werden kommerziell genutzt
  * D,E - speziell reserviert

  * Sonderregeln
    * im Host-Anteil dürfen nicht alle Bits auf 0 gesetzt werden
      * (das wäre dann eine Subnetzmaske)
    * im Host-Anteil dürfen nicht alle Bits auf 1 gesetzt werden
      * (das wäre dann eine Broadcast-Adresse)
    * das erste Byte müssen aus A, B oder C sein

  * Eine Subnetzmaske beginnt IMMER mit 1 (binär) und danach kommen NUR die 0
    * also 1111...000
    * so was wie 1110001110001100 ist nicht erlaubt

  * Broadcast:
    * alle Host-Bits sind auf 1 gesetzt

  * Multicast
    * "Gruppenadressen"
    * Multicasts werden geroutet (Broadcasts - nicht)
 
  * Warum IP-Adressen?
    * Warum Klassen, wenn Subnetzmaske definiert werden kann?
      * => aus historischen Gründen

  * Öffentliche und private IP-Adressen
    * Öffentliche - kann im Internet geroutet werden
    * Private - werden nicht im Internet weitergeleitet
    * NUR diese Adressen sind privat:
      * A Klasse
        * 10.0.0.0 - 10.255.255.255 (8 Netze)
      * B Klasse
        * 172.16.0.0 - 172.31.255.255 (12 Netze)
      * C Klasse
        * 192.168.0.0 - 192.168.255.255 (16 Netze)
    * Siehe auch "CIDR" (Classless Inter-Domain Routing)


  * Übung:
    * Welche Adressen sind gültig / nicht gültig und warum:
      * 131.107.256.80
        * nicht gültig
        * wg. 256
      * 222.222.255.222
        * gültig
      * 231.200.1.1
        * nicht gültig
        * Multicast
      * 198.121.254.255
        * nicht gültig
        * Broadcast
      * 126.1.0.0
        * gültig
      * 0.127.4.100
        * nicht gültig
        * wg. 0
      * 127.1.1.1
        * nicht gültig
        * (local host?)
      * 190.7.2.0
        * gültige B-Klasse
      * 255.255.255.255
        * nicht gültig
        * Broadcast
      * 1.0.0.1
        * gültige A-Klasse
      * 172.18.254.255
        * gültig B-Klasse
      * 1.255.0.0
        * gültig A-Klasse

  * Anzahl Hosts pro Subnetz für Klasse A
    * Anzahl Bits im Host-Anteil (s. Diagramm in der Präsentation von Michael) = 2^24 = 16.777.216
    * Minus 2 (im Host-Anteil stehen alle Bits auf 0 oder alle Bits stehen auf 1)
    * => 16.777.214
  * Anzahl Hosts pro Subnetz für Klasse B
    * Anzahl Bits im Host-Anteil (s. Diagramm in der Präsentation von Michael) = 2^16 = 65.536
    * Minus 2 (im Host-Anteil stehen alle Bits auf 0 oder alle Bits stehen auf 1)
    * => 65.534
  * Anzahl Hosts pro Subnetz für Klasse C
    * Anzahl Bits im Host-Anteil (s. Diagramm in der Präsentation von Michael) = 2^8 = 256
    * Minus 2 (im Host-Anteil stehen alle Bits auf 0 oder alle Bits stehen auf 1)
    * => 254

  * Zum Nachlesen:
    * Kapitel 7. Vom Einzelrechner zum Netzwerk: Grundlagen 
    * Kapitel 8. Die IP-Adressierung
    * Präsentation von Michael (TCPIP-0225.pdf)

===== Tag 3: 19.02.2025 Mittwoch =====

  * Übungen zu der Berechnung von Subnetzen
    * ...

  * 2 neue Rechner im Hyper-V Manager einrichten
    * W22DC01
      * Windows Server 2022 (Desktopdarstellung = "mit GUI")
      * 10.0.1.1/24
      * Subnetzmaske 255.255.255.0
      * Administrator / Pa$$w0rt
    * W22DC02
      * Windows Server 2022 (Desktopdarstellung = "mit GUI")
      * 10.0.1.2/24
      * Subnetzmaske 255.255.255.0
      * Administrator / Pa$$w0rt

  * ...

  * Misc
    * Wie man Subnetzmasken berechnet:
      * https://www.computerweekly.com/de/tipp/IP-Adressen-und-Subnetze-Wie-man-IPv4-Subnetzmasken-mit-der-Host-Formel-berechnet
    * Sebastian Philippi YouTube-Channel
      * [[https://www.youtube.com/watch?v=am38FIbvD28|Quick and dirty! Subnetting "Like a Pro"]]
    * evtl. auch https://www.youtube.com/watch?v=-qQ8mPHGd1U
    * Verschiedene Subnetzmasken-Rechner:
      * Heise: https://www.heise.de/netze/tools/netzwerkrechner

===== Tag 4: 20.02.2025 Donnerstag =====

  * 2 neue Rechner im Hyper-V Manager einrichten
    * W22FS01 (File Server)
      * Windows Server 2022 (Desktopdarstellung = "mit GUI")
      * 10.0.2.1/24
      * Subnetzmaske 255.255.255.0
      * Administrator / Pa$$w0rt
    * W11CL01 (Client)
      * Windows 11 Pro
      * 10.0.2.100/24
      * Subnetzmaske 255.255.255.0
      * 4 GB RAM (sonst lässt er sich nicht installieren)
        * danach kann man das im Hyper-V reduzieren
      * Pa$$w0rt

  * Router im Hype-V Manager erstellen
    * Windows Server 2022 (Desktopdarstellung = "mit GUI")
    * W22RT01
      * Hardware hinzufügen
        * 2-te Netzwerkkarte hinzufügen (=> im Hyper-V Manager auf Eigenschaften des Rechners  => Hardware hinzufügen)
          * 1-te = 10.0.1.254 / 24
            * Subnetzmaske 255.255.255.0
          * 2-te = 10.0.2.254 / 24
            * Subnetzmaske 255.255.255.0
      * Administrator / Pa$$w0rt


===== Tag 5: 21.02.2025 Freitag =====

  * Supernetting (nicht prüfungsrelevant)
    * ...
  * NetBIOS
    * Namensauflösung in einer NICHT-hierarchischen Form
  
  * Agenda
    * Hosttabellen
    * DNS-Server konfigurieren
    * WINS
    * Tools
    * Übungen

  * Namensauflösung
    * A-Record (Host)
    * MX-Record (Mail)
    * TXT-Record
    * SRV-Record (Services)
    * ...

  * Unter ''C:\Windows\System32\drivers\etc\lmhosts''
    * Zuordnung IP -> Name (über WINS?)
  * Unter ''C:\Windows\System32\drivers\etc\hosts''
    * zum Testen, wenn man z.B. (DNS?)-Server nicht anfassen darf/kann 

  * DNS = Domain Name System
    * Service
    * auch eigenes Protokoll im TCP/IP

  * Grundlagen
    * TTL - Time To Live
    * ...
    * Top-Level Domains
      * com, gov, edu ...
      * länderspezifische (de, es, ru,...)
      * neue (aero, info,...)
    * in-addr.arpa
      * Zuordnung IP -> Name 
        * (also andersrum)

  * Namensauflösung
  * kaskadierte DNS Systeme

  * Serverrollen
    * Primary
    * Secondary
    * Caching-Only-Server

  * Nachlesen im Buch 1 unter "Tag 9. Wie finden sich..."

  * Aufgabe (zusammen gelöst)
    * "W22DC01" als DNS-Server einrichten
      * Server Manager / Verwalten / Rollen und... hinzufügen

  * Stammhinweise
    * Liste der (.) Root-Server
      * 13 Stück(normalerweise/immer?)

  * Forward Lookup Zone erstellen
    * Primäre Zone 
      * (auf dem primären Server-> primäre zone)
      * (auf dem sekundären Server-> sekundäre zone)

  * Reverse Lookup Zone erstellen
    * ...

  * ''ipconfig /displaydns''
    * DNS Cache anschauen
  * ''ipconfig /flushdns''
    * DNS Cache löschen

  * ARP Cache __UND__ DNS Cache am besten beide löschen, da veraltete Caches zu den Fehlern führen


  * Sekundären DNS Server auf ''W22DC02'' installieren
    * ...