Windows Server i PowerShell

Active Directory Domain Services (AD DS) to usługa katalogowa Microsoftu, która centralizuje zarządzanie użytkownikami, komputerami, uprawnieniami i politykami bezpieczeństwa. Choć kojarzy się z korporacjami, nawet w domu z kilkoma komputerami AD znacznie ułatwia życie: jedno konto, jedno hasło, dostęp do zasobów sieciowych bez oddzielnych konfiguracji na każdym komputerze.

1. Instalacja roli AD DS przez PowerShell

Zamiast klikać przez GUI, użyjemy PowerShell – szybciej i możesz zdokumentować każdy krok. Uruchom PowerShell jako Administrator:

# Sprawdź dostępne role
Get-WindowsFeature | Where-Object Name -like "*AD*"

# Zainstaluj AD DS i narzędzia zarządzania
Install-WindowsFeature -Name AD-Domain-Services `
                       -IncludeManagementTools `
                       -IncludeAllSubFeature

# Zaimportuj moduł ADDSDeployment
Import-Module ADDSDeployment

2. Promocja serwera do kontrolera domeny

# Utwórz nowy las AD (nowa domena)
Install-ADDSForest `
  -DomainName "domhome.local" `
  -DomainNetbiosName "DOMHOME" `
  -ForestMode "WinThreshold" `
  -DomainMode "WinThreshold" `
  -InstallDns:$true `
  -SafeModeAdministratorPassword (ConvertTo-SecureString "Hasl0!DSRMpass" -AsPlainText -Force) `
  -Force:$true

# Serwer automatycznie uruchomi się ponownie
# Po restarcie zaloguj się jako DOMHOME\Administrator

3. Zarządzanie użytkownikami przez PowerShell

# Utwórz jednostkę organizacyjną (OU)
New-ADOrganizationalUnit -Name "Dom" -Path "DC=domhome,DC=local"
New-ADOrganizationalUnit -Name "Uzytkownicy" -Path "OU=Dom,DC=domhome,DC=local"
New-ADOrganizationalUnit -Name "Komputery" -Path "OU=Dom,DC=domhome,DC=local"

# Utwórz użytkownika
New-ADUser `
  -Name "Jan Kowalski" `
  -GivenName "Jan" `
  -Surname "Kowalski" `
  -SamAccountName "j.kowalski" `
  -UserPrincipalName "j.kowalski@domhome.local" `
  -Path "OU=Uzytkownicy,OU=Dom,DC=domhome,DC=local" `
  -AccountPassword (ConvertTo-SecureString "Haslo1234!" -AsPlainText -Force) `
  -Enabled $true `
  -PasswordNeverExpires $false `
  -ChangePasswordAtLogon $true

# Dodaj użytkownika do grupy
Add-ADGroupMember -Identity "Domain Users" -Members "j.kowalski"

# Masowe tworzenie użytkowników z CSV
Import-Csv "uzytkownicy.csv" | ForEach-Object {
  New-ADUser -Name "$($_.Imie) $($_.Nazwisko)" `
    -SamAccountName $_.Login `
    -AccountPassword (ConvertTo-SecureString $_.Haslo -AsPlainText -Force) `
    -Enabled $true `
    -Path "OU=Uzytkownicy,OU=Dom,DC=domhome,DC=local"
}

4. Zasady grupowe (GPO) – przykłady praktyczne

GPO (Group Policy Objects) pozwala narzucić ustawienia na wszystkie komputery i użytkowników w domenie jednocześnie. Otwórz Group Policy Management z narzędzi administracyjnych.

# Przydatne ustawienia GPO przez PowerShell (RSAT)

# Wyłącz Autoplay na wszystkich komputerach
Set-GPRegistryValue -Name "Bezpieczenstwo" `
  -Key "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\Explorer" `
  -ValueName "NoDriveTypeAutoRun" `
  -Type DWord `
  -Value 255

# Ustaw stronę domową w przeglądarce Edge
Set-GPRegistryValue -Name "Uzytkownicy" `
  -Key "HKCU\SOFTWARE\Policies\Microsoft\Edge" `
  -ValueName "HomepageLocation" `
  -Type String `
  -Value "https://ipraktyk.pl"

# Wymuś aktualizacje GPO na kliencie
gpupdate /force

5. Dołączanie Windows 10/11 do domeny

# Na komputerze klienckim (Windows 10/11)
# Ustaw DNS na IP kontrolera domeny np. 192.168.1.10
Set-DnsClientServerAddress -InterfaceAlias "Ethernet" `
  -ServerAddresses ("192.168.1.10","8.8.8.8")

# Dołącz do domeny
Add-Computer -DomainName "domhome.local" `
             -Credential (Get-Credential) `
             -Restart

# Lub przez GUI: Ustawienia → System → Informacje → Zaawansowane ustawienia systemu
# → Nazwa komputera → Zmień → Domena: domhome.local

PowerShell to nie tylko linia komend – to pełnoprawny język skryptowy zintegrowany z systemem Windows. Możesz nim zarządzać usługami, monitorować zasoby, tworzyć raporty, konfigurować sieć i automatyzować codzienne zadania administratora. Poniżej 20 gotowych do użycia skryptów.

1. Raport zajętości dysków (HTML)

$report = Get-PSDrive -PSProvider FileSystem | Select-Object Name,
  @{N='Wolne (GB)'; E={[math]::Round($_.Free/1GB, 2)}},
  @{N='Użyte (GB)'; E={[math]::Round(($_.Used)/1GB, 2)}},
  @{N='Razem (GB)'; E={[math]::Round(($_.Free+$_.Used)/1GB, 2)}},
  @{N='Zajęte (%)'; E={[math]::Round(($_.Used/($_.Free+$_.Used))*100, 1)}}
$report | ConvertTo-Html -Title "Dyski" | Out-File "$env:TEMP\dyski.html"
Invoke-Item "$env:TEMP\dyski.html"

2. Monitoring procesów pochłaniających CPU

# Top 10 procesów wg CPU, odświeżanie co 5 sekund
while ($true) {
  Clear-Host
  Write-Host "Top 10 procesów (CPU) - $(Get-Date -Format 'HH:mm:ss')" -ForegroundColor Cyan
  Get-Process | Sort-Object CPU -Descending | Select-Object -First 10 `
    Name, Id,
    @{N='CPU (s)'; E={[math]::Round($_.CPU, 1)}},
    @{N='RAM (MB)'; E={[math]::Round($_.WorkingSet64/1MB, 1)}} |
    Format-Table -AutoSize
  Start-Sleep 5
}

3. Backup folderów z kompresją

function Backup-Folder {
  param(
    [string]$Source = "C:\Dane",
    [string]$Dest   = "D:\Backupy",
    [int]   $Keep   = 7  # ile kopii zachować
  )
  $date    = Get-Date -Format "yyyy-MM-dd_HHmm"
  $zipFile = Join-Path $Dest "backup_$date.zip"
  New-Item -ItemType Directory -Force $Dest | Out-Null
  Compress-Archive -Path $Source -DestinationPath $zipFile
  Write-Host "✓ Backup: $zipFile" -ForegroundColor Green

  # Usuń stare kopie
  Get-ChildItem $Dest -Filter "backup_*.zip" |
    Sort-Object LastWriteTime -Descending |
    Select-Object -Skip $Keep |
    Remove-Item -Force
}

Backup-Folder -Source "C:\Dokumenty" -Dest "D:\Backupy" -Keep 7

4. Skanowanie otwartych portów w sieci lokalnej

# Szybki skan portów wybranych hostów
function Test-Port {
  param([string]$Host, [int[]]$Ports = @(22,80,443,3389,8080))
  foreach ($port in $Ports) {
    $tcp = New-Object Net.Sockets.TcpClient
    $conn = $tcp.BeginConnect($Host, $port, $null, $null)
    $ok   = $conn.AsyncWaitHandle.WaitOne(200)
    $status = if ($ok -and $tcp.Connected) { "OPEN" } else { "closed" }
    $tcp.Close()
    [PSCustomObject]@{ Host=$Host; Port=$port; Status=$status }
  }
}

# Skanuj urządzenia
"192.168.1.1","192.168.1.10","192.168.1.100" | ForEach-Object {
  Test-Port -Host $_ | Where-Object Status -eq "OPEN"
} | Format-Table -AutoSize

5. Automatyczne tworzenie zadań zaplanowanych

# Uruchom skrypt backup.ps1 codziennie o 2:00 w nocy
$action  = New-ScheduledTaskAction -Execute "PowerShell.exe" `
           -Argument "-NonInteractive -File C:\Skrypty\backup.ps1"
$trigger = New-ScheduledTaskTrigger -Daily -At "02:00"
$settings = New-ScheduledTaskSettingsSet -RunOnlyIfNetworkAvailable $false `
            -StartWhenAvailable $true
Register-ScheduledTask -TaskName "DzizennyBackup" `
  -Action $action -Trigger $trigger -Settings $settings `
  -RunLevel Highest -Force
Write-Host "✓ Zadanie zaplanowane" -ForegroundColor Green

Hyper-V to hipernadzorca (hypervisor) wbudowany w Windows 10/11 Pro i Windows Server. Pozwala tworzyć maszyny wirtualne – izolowane środowiska z własnym systemem operacyjnym. Idealne dla hobbystów do testowania konfiguracji, nauki Linuxa, budowania sieciowych laboratoriów bez kupowania dodatkowego sprzętu.

Włączenie Hyper-V

# Windows 10/11 Pro / Enterprise (jako Administrator)
Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V -All

# Lub przez dism:
dism /Online /Enable-Feature /All /FeatureName:Microsoft-Hyper-V

# Restart wymagany; po restarcie:
Get-VM   # Lista maszyn wirtualnych
Get-VMSwitch  # Lista wirtualnych przełączników sieciowych

Tworzenie maszyny wirtualnej (PowerShell)

# Utwórz przełącznik NAT (maszyna ma dostęp do internetu przez host)
New-VMSwitch -Name "NAT-Switch" -SwitchType Internal
New-NetIPAddress -IPAddress 192.168.100.1 -PrefixLength 24 `
  -InterfaceAlias "vEthernet (NAT-Switch)"
New-NetNat -Name "NATNetwork" -InternalIPInterfaceAddressPrefix "192.168.100.0/24"

# Utwórz maszynę wirtualną z Ubuntu Server
$vmName = "Ubuntu-Lab"
$isoPath = "C:\ISO\ubuntu-24.04-live-server-amd64.iso"
$vmPath  = "D:\VMs"

New-VM -Name $vmName -MemoryStartupBytes 2GB -Generation 2 `
       -NewVHDPath "$vmPath\$vmName\disk.vhdx" `
       -NewVHDSizeBytes 40GB -Path $vmPath `
       -SwitchName "NAT-Switch"

Set-VM -Name $vmName -ProcessorCount 2 `
       -DynamicMemory -MemoryMinimumBytes 1GB -MemoryMaximumBytes 4GB

# Dodaj ISO jako DVD
Add-VMDvdDrive -VMName $vmName -Path $isoPath

# Ustaw kolejność bootowania (Gen2 – UEFI)
$dvd = Get-VMDvdDrive -VMName $vmName
Set-VMFirmware -VMName $vmName `
  -BootOrder $dvd,(Get-VMHardDiskDrive -VMName $vmName)

# Uruchom VM
Start-VM -Name $vmName
vmconnect localhost $vmName

Checkpoint (snapshot) – stan maszyny przed ryzykowną operacją

# Utwórz punkt kontrolny przed instalacją oprogramowania
Checkpoint-VM -Name "Ubuntu-Lab" -SnapshotName "Przed instalacja Docker"

# Po problemie – przywróć do poprzedniego stanu
Restore-VMCheckpoint -Name "Ubuntu-Lab" `
  -VMCheckpointName "Przed instalacja Docker" -Confirm:$false
Start-VM -Name "Ubuntu-Lab"

# Lista checkpointów
Get-VMCheckpoint -VMName "Ubuntu-Lab"

# Usuń niepotrzebny checkpoint (zwalnia miejsce na dysku)
Remove-VMCheckpoint -VMName "Ubuntu-Lab" -VMCheckpointName "Stary snapshot"

Sieciowe laboratorium – kilka VM w izolowanej sieci

# Wirtualna sieć izolowana (bez dostępu do internetu – do testów bezpiecznych)
New-VMSwitch -Name "IzoLab" -SwitchType Private

# Utwórz VM router (np. pfSense) z dwoma kartami
New-VM -Name "pfSense-Router" -MemoryStartupBytes 1GB `
       -NewVHDPath "D:\VMs\pfSense\disk.vhdx" -NewVHDSizeBytes 8GB `
       -Path "D:\VMs" -SwitchName "NAT-Switch"
Add-VMNetworkAdapter -VMName "pfSense-Router" -SwitchName "IzoLab"

# Klienci w izolowanej sieci przez pfSense
New-VM -Name "Klient-1" -MemoryStartupBytes 1GB `
       -NewVHDPath "D:\VMs\Klient1\disk.vhdx" -NewVHDSizeBytes 20GB `
       -Path "D:\VMs" -SwitchName "IzoLab"