Automation & Scripting – PowerShell, Bash, Python & IaC

Inhaltsverzeichnis

Schnellübersicht

Auf dieser Seite lernst du alles über Automation & Scripting:

Definition: Was ist Automation & Scripting?
Scripting-Sprachen: PowerShell, Bash, Python, Ansible, Terraform, Jenkins
Code-Beispiele: Praktische Scripts für typische Aufgaben
Use Cases: Benutzerverwaltung, Softwareverteilung, Backup, Monitoring
Best Practices: Version Control, Dokumentation, Security
FAQ: Häufige Fragen und Troubleshooting

1. Was ist Automation & Scripting?

Definition

Automation & Scripting bezeichnet die Automatisierung wiederkehrender IT-Aufgaben durch Programmierung (Scripts) und spezialisierte Tools. Statt Aufgaben manuell durchzuführen, werden sie durch Code automatisiert – schneller, fehlerfreier und skalierbar.

Scripting ist das Schreiben von Code-Snippets (Scripts) zur Automatisierung spezifischer Aufgaben. Automation ist der übergeordnete Begriff für die Automatisierung ganzer Workflows und Prozesse, oft durch Kombination mehrerer Scripts und Tools.

Infrastructure as Code (IaC) ist eine moderne Form der Automation, bei der Infrastruktur (Server, Netzwerke, Cloud-Ressourcen) durch Code definiert und bereitgestellt wird – z.B. mit Terraform, Ansible oder CloudFormation.

             Warum Automation?
            Zeitersparnis: Wiederkehrende Aufgaben werden in Sekunden statt Stunden erledigt
Fehlerreduktion: Keine manuellen Fehler durch Konsistenz
Skalierbarkeit: Ein Script kann 1 oder 10.000 Systeme verwalten
Dokumentation: Code dokumentiert sich selbst
Reproduzierbarkeit: Gleiche Ergebnisse bei jeder Ausführung
Compliance: Nachweisbare, auditierbare Prozesse

        

2. Die wichtigsten Scripting-Sprachen & Tools

Hier eine Übersicht der wichtigsten Scripting-Sprachen und Automation-Tools:

WINDOWS

PowerShell

Windows Automation Standard

Mächtige Shell und Scripting-Sprache von Microsoft. Standard für Windows-Administration.

Objektorientiert (keine Textverarbeitung)
Cmdlets für alle Windows-Aufgaben
Remote-Management (WinRM)
Pipeline-Konzept
Cross-Platform (PowerShell Core)

Windows, Linux, macOS Mittel

LINUX

Bash / Shell

Linux Command Line

Die Standard-Shell für Linux/Unix. Ideal für Systemadministration und Automatisierung.

Textbasierte Verarbeitung
Pipes und Redirection
Cron Jobs für Scheduling
SSH für Remote-Management
Standard auf allen Linux-Systemen

Linux, macOS, Unix Mittel

UNIVERSAL

Python

Plattformübergreifende Automatisierung

Vielseitige Programmiersprache mit umfangreichen Bibliotheken für Automation.

Einfach zu lernen und zu lesen
Riesige Bibliothek (PyPI)
API-Integration (requests, httpx)
Cloud-Automation (boto3, azure-sdk)
Data Science & KI

Alle Plattformen Einfach

CONFIG MGMT

Ansible

Configuration Management & Orchestration

Agentenloses Automation-Tool für Konfigurationsmanagement und Orchestrierung.

YAML-basierte Playbooks
Agentenlos (nur SSH/WinRM)
Idempotent (wiederholbar)
Umfangreiche Module
Ansible Tower/AWX für Enterprise

Alle Plattformen Mittel

IaC

Terraform

Infrastructure as Code

Declarative IaC-Tool zur Bereitstellung von Cloud- und On-Premise-Infrastruktur.

HCL (HashiCorp Configuration Language)
Multi-Cloud (AWS, Azure, GCP)
State Management
Provider-Ökosystem
Terraform Cloud für Enterprise

Multi-Cloud Mittel

CI/CD

Jenkins / GitLab CI

Continuous Integration & Delivery

CI/CD-Server zur Automatisierung von Build, Test und Deployment-Pipelines.

Jenkinsfile / .gitlab-ci.yml
Pipeline as Code
Plugins für alle Tools
Automated Testing
Deployment-Automation

Self-Hosted Fortgeschritten

3. Code-Beispiele

Hier einige praktische Beispiele für typische Automation-Aufgaben:

PowerShell: Benutzer anlegen

            PowerShell
# Neuen AD-Benutzer anlegen
Import-Module ActiveDirectory

$username = "max.mustermann"
$password = ConvertTo-SecureString "P@ssw0rd123!" -AsPlainText -Force

New-ADUser -Name "Max Mustermann" `
    -SamAccountName $username `
    -UserPrincipalName "$username@firma.local" `
    -Path "OU=Users,DC=firma,DC=local" `
    -AccountPassword $password `
    -Enabled $true `
    -ChangePasswordAtLogon $true

Write-Host "Benutzer $username wurde erfolgreich angelegt." -ForegroundColor Green
        

Bash: System-Update

            Bash
#!/bin/bash
# System-Update Script für Ubuntu/Debian

echo "Starte System-Update..."

# Paketlisten aktualisieren
sudo apt update

# Pakete upgraden
sudo apt upgrade -y

# Nicht mehr benötigte Pakete entfernen
sudo apt autoremove -y

# Prüfen, ob Neustart erforderlich
if [ -f /var/run/reboot-required ]; then
    echo "Neustart erforderlich. Führe Neustart in 60 Sekunden aus..."
    sudo shutdown -r +1 "System-Update abgeschlossen. Neustart erforderlich."
else
    echo "Update abgeschlossen. Kein Neustart erforderlich."
fi
        

Python: API-Abfrage

            Python
# Wetter-API abfragen
import requests
import json

def get_weather(city):
    api_key = "YOUR_API_KEY"
    url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric"
    
    try:
        response = requests.get(url)
        data = response.json()
        
        if response.status_code == 200:
            temp = data['main']['temp']
            desc = data['weather'][0]['description']
            print(f"Wetter in {city}: {temp}°C, {desc}")
        else:
            print(f"Fehler: {data['message']}")
    except Exception as e:
        print(f"Fehler bei API-Abfrage: {e}")

get_weather("Berlin")
        

Ansible: Webserver installieren

            YAML
# Ansible Playbook: Nginx installieren und konfigurieren
---
- name: Install and configure Nginx
  hosts: webservers
  become: yes
  
  tasks:
    - name: Install Nginx
      apt:
        name: nginx
        state: present
        update_cache: yes
    
    - name: Start Nginx service
      service:
        name: nginx
        state: started
        enabled: yes
    
    - name: Deploy custom index.html
      copy:
        src: files/index.html
        dest: /var/www/html/index.html
        mode: '0644'
    
    - name: Allow HTTP traffic
      ufw:
        rule: allow
        port: '80'
        proto: tcp
        

Terraform: AWS EC2 Instance

            HCL
# Terraform: AWS EC2 Instance erstellen
provider "aws" {
  region = "eu-central-1"
}

resource "aws_instance" "web_server" {
  ami           = "ami-0c55b159cbfafe1f0"  # Amazon Linux 2
  instance_type = "t2.micro"
  
  tags = {
    Name        = "WebServer"
    Environment = "Production"
  }
  
  user_data = <<-EOF
              #!/bin/bash
              yum update -y
              yum install -y httpd
              systemctl start httpd
              systemctl enable httpd
              EOF
}

output "public_ip" {
  value = aws_instance.web_server.public_ip
}
        

4. Use Cases – Typische Automatisierungsaufgaben

Die wichtigsten Einsatzgebiete für Automation & Scripting:

Benutzerverwaltung

AD-Benutzer anlegen/löschen
Gruppenmitgliedschaften verwalten
Passwort-Reset automatisieren
Onboarding/Offboarding
Lizenz-Zuweisung (Office 365)

Softwareverteilung

Software-Installation automatisieren
Updates verteilen (Patch Management)
Konfigurations-Deployment
SCCM/Intune Automation
Chocolatey/Winget Scripts

Backup & Recovery

Automatische Backups planen
Backup-Verifikation
Retention-Policies anwenden
Off-Site Replication
Disaster Recovery Testing

Monitoring & Alerting

System-Metriken sammeln
Alerts bei Schwellenwerten
Log-Analyse automatisieren
Performance-Reports generieren
Health-Checks durchführen

Konfigurationsmanagement

Server-Konfigurationen synchronisieren
Compliance-Checks durchführen
Drift Detection
Configuration Baselines
Ansible Playbooks ausführen

CI/CD Pipelines

Automated Builds
Automated Testing
Deployment-Automation
Rollback-Mechanismen
Blue-Green Deployments

5. Best Practices

Die wichtigsten Empfehlungen für professionelle Automation & Scripting:

Version Control

Alle Scripts in Git versionieren
Branching-Strategie verwenden
Meaningful Commit Messages
Code Reviews durchführen
Tags für Releases nutzen

Dokumentation

Header-Kommentare in jedem Script
Parameter und Rückgabewerte dokumentieren
README.md für Script-Sammlungen
Beispiele für typische Anwendungsfälle
Changelog pflegen

Error Handling

Try-Catch-Blöcke verwenden
Sinnvolle Fehlermeldungen ausgeben
Exit-Codes setzen
Logging implementieren
Fallback-Mechanismen

Security

Keine Hardcoded Credentials
Secrets in Vault/Key Management
Least Privilege Principle
Script-Signaturen verwenden
Regelmäßige Security-Audits

Testing

Unit Tests für Functions
Integration Tests für Workflows
Test in isolierter Umgebung
Mock externe Abhängigkeiten
Automated Testing in CI/CD

Modularität

Functions statt monolithischer Scripts
Wiederverwendbare Module erstellen
Parameter statt Hardcoding
Configuration Files nutzen
DRY-Prinzip (Don't Repeat Yourself)

6. FAQ – Häufige Fragen

Häufige Fragen zu Automation & Scripting

Welche Scripting-Sprache soll ich lernen?

Empfehlung nach Einsatzgebiet:

Windows-Administration: PowerShell (Pflicht)
Linux-Administration: Bash (Pflicht) + Python
Cloud-Automation: Python + Terraform
Configuration Management: Ansible
CI/CD: Jenkins Pipeline / GitLab CI
Allgemeine Automation: Python (am vielseitigsten)

Tipp: Lerne zuerst PowerShell oder Bash (je nach Plattform), dann Python für komplexe Aufgaben.

Was ist der Unterschied zwischen Scripting und Programmierung?

Scripting:

Kürzere Code-Snippets (Scripts)
Interpretiert (keine Kompilierung)
Fokus auf Automatisierung
Weniger komplex, schneller zu schreiben
Beispiele: PowerShell, Bash, Python

Programmierung:

Komplexere Anwendungen
Oft kompiliert (C++, Java, C#)
Fokus auf Software-Entwicklung
Mehr Struktur und Design Patterns
Längere Entwicklungszyklen

Wie sichere ich Credentials in Scripts?

Best Practices für Credential-Management:

Niemals Hardcoding: Keine Passwörter im Code
Environment Variables: Für einfache Fälle
Secret Management: Azure Key Vault, AWS Secrets Manager, HashiCorp Vault
Managed Identities: In Azure/AWS (keine Credentials nötig)
Credential Manager: Windows Credential Manager
Encrypted Files: Für lokale Scripts

Beispiel PowerShell:

# Credential aus Windows Credential Manager
$cred = Get-StoredCredential -Target "MyApp"

# Oder aus Azure Key Vault
$secret = Get-AzKeyVaultSecret -VaultName "MyVault" -Name "MySecret"
                    

Was ist Infrastructure as Code (IaC)?

Infrastructure as Code (IaC) ist die Definition und Bereitstellung von IT-Infrastruktur durch Code statt manueller Konfiguration.

Vorteile:

Versionierung: Infrastruktur-Änderungen in Git tracken
Reproduzierbarkeit: Gleiche Umgebung immer wieder erstellen
Automation: Keine manuelle Konfiguration
Collaboration: Code Reviews für Infrastruktur
Disaster Recovery: Schnelle Wiederherstellung

Wichtige IaC-Tools:

Terraform: Multi-Cloud, declarative
CloudFormation: AWS-spezifisch
ARM Templates: Azure-spezifisch
Pulumi: Mit echten Programmiersprachen
Ansible: Configuration Management

Wie teste ich Scripts sicher?

Best Practices für Script-Testing:

Isolierte Umgebung: Test-VMs oder Container
Dry-Run-Modus: Viele Tools haben -WhatIf oder -DryRun
Staging-Umgebung: Erst in Test, dann in Produktion
Rollback-Plan: Immer Rückgängigmachen möglich
Monitoring: Script-Ausführung überwachen
Logging: Alle Aktionen protokollieren

Beispiel PowerShell mit -WhatIf:

# Testen ohne Änderungen
Remove-ADUser -Identity "test.user" -WhatIf

# Erst ausführen, wenn sicher
Remove-ADUser -Identity "test.user" -Confirm:$false
                    

Wie plane ich Script-Ausführungen (Scheduling)?

Scheduling-Optionen:

Windows Task Scheduler: Für Windows-Scripts
Cron (Linux): Für Bash/Python-Scripts
Jenkins/GitLab CI: Für komplexe Pipelines
Azure Automation: Cloud-basiert für Azure
AWS Lambda + EventBridge: Serverless Scheduling
Kubernetes CronJobs: Für Container-Workloads

Beispiel Cron Job (täglich um 2 Uhr):

# Crontab bearbeiten
crontab -e

# Script täglich um 2:00 Uhr ausführen
0 2 * * * /path/to/script.sh >> /var/log/script.log 2>&1
                    

Wie debugge ich Scripts?

Debugging-Techniken:

Write-Host / echo: Einfache Ausgabe von Variablen
Set-PSDebug -Trace 1: PowerShell Debug-Modus
bash -x script.sh: Bash Debug-Modus
Breakpoints: In IDEs (VS Code, ISE)
Logging Frameworks: Structured Logging
Error Variables: $Error in PowerShell, $? in Bash

Beispiel PowerShell Debugging:

# Debug-Modus aktivieren
Set-PSDebug -Trace 2

# Breakpoint setzen
Set-PSBreakpoint -Script script.ps1 -Line 10

# Variable inspizieren
$variable | Format-List *
                    

Welche IDE/Editor für Scripting?

Empfohlene Editoren:

VS Code: Kostenlos, Extensions für alle Sprachen
PowerShell ISE: Nur Windows, veraltet
Visual Studio: Für komplexe Projekte
PyCharm: Speziell für Python
Vim/Neovim: Terminal-basiert, für Profis
Sublime Text: Leichtgewichtig, schnell

VS Code Extensions:

PowerShell Extension
Python Extension
Bash Debug
Terraform
YAML
GitLens

Zusammenfassung

             Die wichtigsten Punkte
            Automation & Scripting: Automatisierung wiederkehrender IT-Aufgaben durch Code
PowerShell: Standard für Windows-Administration, objektorientiert
Bash: Standard für Linux-Administration, textbasiert
Python: Vielseitigste Sprache, riesige Bibliothek
Ansible: Agentenloses Configuration Management
Terraform: Infrastructure as Code für Multi-Cloud
Jenkins/GitLab CI: CI/CD Pipelines
Best Practices: Version Control, Dokumentation, Error Handling, Security, Testing
Credential Management: Niemals Hardcoding, Vault/Key Management nutzen
Testing: Isolierte Umgebung, Dry-Run, Rollback-Plan

        

Nächste Schritte

Bereit, mit Automation & Scripting zu starten? Hier ein empfohlener Weg:

Plattform wählen: Windows → PowerShell, Linux → Bash
Grundlagen lernen: Syntax, Variablen, Functions, Loops
Erste Scripts schreiben: Einfache Automatisierungen
Python lernen: Für komplexe Aufgaben und API-Integration
IaC-Tools: Terraform oder Ansible für Infrastructure as Code
CI/CD aufsetzen: Jenkins oder GitLab CI für Pipelines
Best Practices anwenden: Git, Testing, Documentation, Security
Community nutzen: GitHub, Stack Overflow, Dokumentation

Weiterführende Themen

Windows Server

Windows Server Administration – Active Directory, Hyper-V, GPO.

Zu Windows Server

Linux Server

Linux-Server im Enterprise-Einsatz – Bash, Systemd, Package Management.

Zu Linux Server

Infrastructure as Code

Terraform, CloudFormation, ARM Templates – IaC im Detail.

Zu IaC

DevOps

DevOps-Praktiken, CI/CD, Container, Kubernetes.

Zu DevOps