Tutorial: GitHub Copilot für PowerShell-Skripte verwenden

So funktioniert GitHub Copilot

Copilot wendet generative KI-Modelle an, die auf öffentlichem Code trainiert wurden, um die nächsten Zeilen, Blöcke oder gesamten Funktionen basierend auf Ihrer aktuellen Datei, dem Projektkontext und den Prompts vorherzusagen und vorzuschlagen.

In VS Code können Sie einen beschreibenden Kommentar oder String eingeben, und GitHub Copilot bietet Ihnen einen Entwurf an, den Sie verfeinern können. Je klarer Ihre Absicht, Einschränkungen und Umgebungsdetails – PowerShell-Version, Modulnamen und -versionen, Zielbetriebssystem – sind, desto besser sind die Vorschläge. Grundkenntnisse in PowerShell helfen Ihnen, GitHub Copilot zu korrekten, effizienten Skripten zu führen und veraltete Muster zu vermeiden.

GitHub Copilot reagiert auf Feedback im Arbeitsablauf. Wenn es ein veraltetes Cmdlet oder eine veraltete API vorschlägt und Sie diese durch das moderne Äquivalent ersetzen, werden nachfolgende Vervollständigungen in der Regel an Ihre Korrektur angepasst.

Wenn Sie beispielsweise ein Azure-Automatisierungsskript entwerfen, schlägt GitHub Copilot möglicherweise zunächst ein veraltetes AzureRM Login-Cmdlet vor. Durch die Verwendung von Connect‑AzAccount wird es dazu angeleitet, in späteren Vorschlägen Cmdlets im aktuellen Az-Modul zu verwenden. Diese Anpassungsfähigkeit ist wertvoll, ersetzt jedoch nicht die Überprüfung durch Experten.

Einige praktische Tipps, die Sie beachten sollten:

• Die Qualität hängt von der Klarheit Ihrer Prompts ab. Geben Sie ausdrücklich „Ziel PowerShell 7“ an, legen Sie Module wie Az.Accounts oder Az.Compute fest und nennen Sie die erforderlichen Eigenschaften, um Nacharbeiten zu reduzieren.
• Vorschläge können auf veralteten oder suboptimalen Mustern basieren. Überprüfen Sie die Richtigkeit, Leistung und Sicherheit, bevor Sie sie übernehmen. GitHub Copilot ist kein Ersatz für Fachwissen oder Überprüfungsprozesse.
• GitHub Copilot lernt allgemeine Codierungskonventionen aus öffentlichen Repositorys. Es kopiert Ihren privaten Code nicht, es sei denn, Sie erlauben ausdrücklich die Verwendung Ihrer Inhalte für Produktverbesserungen. Sie können bei der Einrichtung auch festlegen, ob Vorschläge mit öffentlichen Codemustern übereinstimmen dürfen.

Die Verwendung von GitHub Copilot vorbereiten

Eine kleine Vorabkonfiguration verbessert die Ergebnisse erheblich, insbesondere in Unternehmensumgebungen.

Plan auswählen und GitHub Copilot aktivieren

1. Als erstes benötigen Sie ein GitHub-Konto. Aktivieren Sie Copilot in Ihren GitHub-Einstellungen (Menu > Copilot). Dort finden Sie auch Testoptionen und Preise. Organisationen können GitHub Copilot für Teams mit Richtlinienkontrollen bereitstellen. Überprüfen Sie vor der Einführung die aktuellen Bedingungen.
2. Bei der Anmeldung können Sie auswählen, ob Sie Vorschläge zulassen möchten, die mit öffentlichem Code übereinstimmen, und ob Sie Ihre Snippets zur Produktverbesserung freigeben möchten. Beide Einstellungen sind optional und sollten mit den Richtlinien Ihrer Organisation übereinstimmen.

GitHub Copilot in VS Code installieren und konfigurieren

1. Installieren Sie die GitHub Copilot-Erweiterung für VS Code und melden Sie sich mit Ihrer GitHub-Identität an. Sobald sie aktiv ist, erscheint im Editor eine Copilot-Statusanzeige.
2. Fügen Sie Copilot Chat hinzu, um Chat-Workflows freizuschalten. Damit kann man Code erklären und refaktorisieren lassen, Tests und Dokumente anfordern und mehrere Dateien ändern. Diese Vorgehensweise ist oft der schnellste Weg zu hochwertigen Ergebnissen.
3. Stellen Sie sicher, dass die PowerShell-Erweiterung für VS Code installiert ist, damit GitHub Copilot mit sprachspezifischer Syntax, Formatierung und Debugging funktioniert.

Bereiten Sie Ihre PowerShell- und Azure-Umgebung vor

1. Setzen Sie standardmäßig eine unterstützte PowerShell 7.x-Laufzeitumgebung ein und halten Sie Kernmodule wie Az-Module für Azure auf dem neuesten Stand. Bitten Sie Copilot um PS7-kompatiblen Code und vermeiden Sie veraltete Cmdlets wie die ältere AzureRM-Familie. Nehmen Sie Inline-Korrekturen vor, wenn Copilot etwas anderes vorschlägt, damit zukünftige Vervollständigungen diesem Beispiel folgen. Die Verwendung eines zentral definierten und verteilten Containers für die lokale Entwicklung ist eine gute Möglichkeit, um sicherzustellen, dass alle dieselbe PowerShell-Version, dieselben Cmdlets und dieselben Tools verwenden.
2. Führen Sie grundlegende Qualitätskontrollen in Ihrem Arbeitsbereich ein, zum Beispiel PSScriptAnalyzer für die Analyse von Quellcode und Pester für Tests, damit Sie die Ausgabe von GitHub Copilot während der Iteration schnell validieren können.

Legen Sie Sicherheits- und Governance-Richtlinien fest

1. Für die individuelle Nutzung überprüfen Sie während der Einrichtung die Optionen Public Code Matching und Content Sharing und wählen Sie die konservativste Einstellung, die dennoch Produktivität ermöglicht.
2. Für Organisationen: Setzen Sie Richtlinien zentral durch, definieren Sie Datengrenzen und entscheiden Sie, wann Sie Repository- oder Workspace-bezogene Unterstützung aktivieren möchten. Behandeln Sie die Ausgabe von GitHub Copilot wie jeden anderen Code-Beitrag: Scannen Sie nach Geheimnissen, überprüfen Sie auf Muster mit geringsten Berechtigungen und prüfen Sie vor dem Zusammenführen auf veraltete Module oder APIs.

Bereiten Sie GitHub Copilot mit effektiven Prompts vor

1. Geben Sie Ziel, Einschränkungen und Umgebung an: PowerShell-Version, Betriebssystem, Module und Leistungs- oder Sicherheitsanforderungen.
2. Fordern Sie ausdrücklich moderne Muster an: „Verwende Get-CimInstance, nicht Get-WmiObject“, „Verwende Connect-AzAccount, nicht AzureRM“, „Gib strukturierte Objekte zurück; vermeide Write-Host“ und „Füge Fehlerbehandlung und -WhatIf-Unterstützung hinzu“. GitHub Copilot reagiert am besten auf diesen Grad an Spezifität.

Mit diesen Vorbereitungen wird GitHub Copilot zu einem zuverlässigen Beschleuniger für PowerShell-Administratoren: Es entwirft die ersten 80 Prozent und Sie wenden Ihr Fachwissen an, um das Ergebnis zu verfeinern und zu festigen. Ihr Feedback leitet die nächsten Vorschläge, ohne dass dabei Korrektheit, Sicherheit und Wartbarkeit aus den Augen verloren werden.

So schreiben Sie PowerShell-Skripte mit GitHub Copilot

GitHub Copilot funktioniert am besten, wenn Sie ihm eine präzise Absicht, eine klare Ausführungsumgebung und Qualitätsrichtlinien vorgeben. Behandeln Sie es wie einen Junior-Paarprogrammierer: Sie legen das Was und die Einschränkungen fest, es entwirft das Wie. Und gemeinsam überprüfen, verfeinern und testen Sie. GitHub Copilot benötigt Anweisungen von Ihnen, um zu verstehen, wie es vorgehen soll. Explizite Prompts führen zu deutlich besseren Ergebnissen.

Iterativ in VS Code arbeiten

• Beginnen Sie mit einem beschreibenden Kommentar oder einem minimalen Funktionsgerüst – CmdletBinding, Parameter, try/catch, ShouldProcess. GitHub Copilot schlägt Ihnen Vervollständigungen vor, die Ihrer Absicht und Ihrem Stil entsprechen.
• Wenn ein Vorschlag fast perfekt ist, akzeptieren Sie ihn und bearbeiten Sie ihn inline. Die nachfolgenden Vervollständigungen von GitHub Copilot in dieser Datei folgen in der Regel Ihren Korrekturen, zum Beispiel dem Wechsel von AzureRM zu Az oder von WMI zu CIM.
• Verwenden Sie GitHub Copilot Chat, um:
  • einen Block erklären oder umgestalten zu lassen,
  • Pester-Tests und Kommentare hinzuzufügen,
  • PSScriptAnalyzer-Regeln durchzusetzen, und
  • die Bearbeitungen mehrerer Dateien anzufordern, zum Beispiel die Aktualisierung eines Moduls und seiner Tests.

Korrektheit, Leistung und Wartbarkeit

• Geben Sie umfangreiche Objekte aus der Pipeline zurück; vermeiden Sie Write-Host im Bibliothekscode.
• Bevorzugen Sie eine einzige, gut abgegrenzte Abfrage. Beispielsweise ist es unnötig und ineffizient, ein Cmdlet innerhalb einer Schleife aufzurufen, wenn Sie bereits über die Daten verfügen.
• Überprüfen Sie die Modulversionen und die Verfügbarkeit von Cmdlets. Bitten Sie GitHub Copilot, relevante Versionen zu fixieren oder zu überprüfen.
• Fügen Sie Fehlerbehandlung und ShouldProcess hinzu, damit Sie während des Testens mit -WhatIf oder -Confirm ausführen können.

Beispiel: Auflisten der ausgeführten Dienste und ihrer Anmeldekonten

Prompt an GitHub Copilot – als Kommentar oder im Chat:

„PowerShell 7. Rufe alle ausgeführten Windows-Dienste ab und zeige den Dienstnamen, den Anzeigenamen und das Konto an, unter dem der Dienst ausgeführt wird. Verwende Get-CimInstance (nicht Get-WmiObject). Gibt Objekte zurück; kein Write-Host.“

Das Ergebnis ist prägnant und PS7-kompatibel.

Führen Sie eine einmalige Abfrage über CIM durch und wählen Sie die benötigten Eigenschaften aus:

$services = Get-CimInstance -ClassName Win32_Service | Where-Object { $_.State -eq ‚Running‘ }
$services | Select-Object Name, DisplayName, State, StartName

Dieser Code vermeidet WMI-Aufrufe pro Dienst und stützt sich für das Anmeldekonto auf Win32_Service.StartName. Außerdem vermeidet er die Verwendung von Eigenschaften, die in Get-Service in PS 7.x nicht vorhanden sind, wie beispielsweise UserName.

Verwenden Sie GitHub Copilot, um die Codequalität zu verbessern

GitHub Copilot unterstützt Sie dabei, über die Grundfunktionen hinaus Best Practices für PowerShell zu implementieren. Es kann ein Skript verfeinern, indem Sie Folgendes anfordern:

• Pester-Tests, die Fehlerbedingungen abdecken.
• Kommentarbasierte Hilfe- und Parametervalidierungsattribute.
• Behebung von PSScriptAnalyzer-Ergebnissen.
• Sicherere Muster, wie Anmeldeinformationen über Get-Credential oder verwaltete Identität; Rollenbasierte Zugriffskontrolle mit geringsten Berechtigungen.
• Wiederholen Sie dies, bis das Skript Ihren Stil- und Zuverlässigkeitsstandards entspricht, und führen Sie dann Tests und einen -WhatIf-Trockenlauf durch, bevor Sie Änderungen anwenden.

Häufige Fehler, die GitHub Copilot macht, und wie Sie diese beheben:

• Veraltete Cmdlets oder Module vorschlagen, wie AzureRM und Get-WmiObject: Korrigieren Sie diese und fahren Sie fort; GitHub Copilot wird in der Regel Ihren Vorgaben bei späteren Vervollständigungen folgen.
• Ineffiziente Schleifen verwenden, die bei jeder Iteration den Status erneut abfragen: Konsolidieren Sie diese zu einer einzigen Abfrage und projizieren Sie nur die Felder, die Sie benötigen.
• Ausgabe von Strings über Write-Host anstelle der Rückgabe von Objekten. Bitten Sie GitHub Copilot, PSCustomObjects auszugeben oder bestimmte Eigenschaften auszuwählen.

Durch die Kombination von klarer Absicht, Umgebungsbeschränkungen und iterativer Überprüfung erhalten Sie von GitHub Copilot präzisen, PowerShell 7-freundlichen und wartbaren Code: Das ist viel schneller als mit einer leeren Datei zu beginnen und sicherer, als den ersten Vorschlag ohne Weiteres zu akzeptieren.

Beispiele für PowerShell-Prompts für GitHub Copilot

Nachfolgend finden Sie ein Prompt-Paket, das Sie in den GitHub Copilot-Chat einfügen und anpassen können. Verwenden Sie Platzhalter wie <FILE>, <FUNCTION>, <MODULE>, <RESOURCE_GROUP>, <PS_VERSION>, <RULESET> und <TARGET>.

Hier sind einige kurze Tipps:

• Geben Sie die PowerShell-Version, Module und Einschränkungen explizit an. GitHub Copilot funktioniert besser mit klaren Anweisungen und aktuellen APIs wie PS7, Az-Modulen und CIM anstelle von WMI.
• Wenn GitHub Copilot veraltete Muster wie AzureRM oder Get-WmiObject vorschlägt, korrigieren Sie diese einmalig; nachfolgende Vervollständigungen folgen in der Regel Ihrer Änderung.
• Bevorzugen Sie einzelne, gut abgegrenzte Abfragen und Rückgabeobjekte. Vermeiden Sie erneute Abfragen pro Element und Write-Host im Bibliothekscode.

Grundlagen/Einschränkungen

„Du bist mein PowerShell-Paarprogrammierer. Einschränkungen: nur PowerShell 7.x; plattformübergreifend sicher; Legacy-Cmdlets vermeiden; AzureRM vermeiden (Az-Module, Connect-AzAccount verwenden); Objekte zurückgeben (kein Write-Host); Fehlerbehandlung (try/catch), Parametervalidierung und ShouldProcess mit -WhatIf/-Confirm hinzufügen; PSScriptAnalyzer-Standardeinstellungen und PowerShell-Stil-Best Practices befolgen.“

Refactoring und Modernisierung nur für PowerShell 7

„Refaktoriere <FILE> nur für PowerShell 7: Ersetze veraltete Cmdlets, stelle plattformübergreifende Kompatibilität sicher, entferne Write-Host zugunsten einer pipelinetauglichen Ausgabe, füge CmdletBinding und ShouldProcess hinzu und füge Hilfskommentare ein. Erläutere jede grundlegende Änderung und warum sie für PS7 erforderlich ist.“

PSScriptAnalyzer-Prüfung und Korrekturen

„Führe PSScriptAnalyzer mit den Standardregeln (oder diesen benutzerdefinierten Einstellungen: <RULESET>) aus. Liste Verstöße mit Regel-IDs und Zeilen auf und schlage dann minimale, sichere Korrekturen vor. Wende die Korrekturen in einer aktualisierten Version von <FILE> an. Wenn eine gerechtfertigte Ausnahme erforderlich ist, füge [Diagnostics.CodeAnalysis.SuppressMessage()] mit einer Begründung in den Kommentaren hinzu.“

Pester-Tests generieren

„Generiere Pester v5-Tests für <FUNCTION>/<MODULE>: Füge die Struktur Arrange/Act/Assert, Mocks für externe Aufrufe (Dateisystem, Registry, Netzwerk, Az-Cmdlets), Tests für -WhatIf/-Confirm, Fehlerpfade, Parametervalidierung und mindestens einen tabellengesteuerten Test hinzu. Ziel ist PS7. Gib die Tests in einer neuen Datei namens <FUNCTION>.Tests.ps1 aus, die für CI geeignet ist.“

Kommentarbasierte Hilfe und Dokumentation

„Füge Hilfskommentare zu <FUNCTION> hinzu: .SYNOPSIS, .DESCRIPTION, .PARAMETER (jeweils), .EXAMPLE (3+ realistische Beispiele), .NOTES, .LINK zur Dokumentation. Erstelle dann einen README-Snippet, das die Verwendung, Voraussetzungen (Module/Versionen) und Beispiele beschreibt.“

„Erstelle für <MODULE> einen CHANGELOG-Eintrag für die Version <TARGET>, in dem Korrekturen, Funktionen und grundlegende Änderungen zusammengefasst und Links zu verwandten Funktionen angegeben sind.“

Standardmäßige Absicherung

„Überprüfe <FILE> auf Sicherheit: Entferne Klartext-Geheimnisse, verwende Get-Credential oder verwaltete Identitätsmuster, validiere alle externen Eingaben, verwende in Beispielen RBAC mit geringsten Berechtigungen, set $ErrorActionPreference = ‚Stop‘ in kritischen Abschnitten und stelle sicher, dass sensible Daten nicht protokolliert werden. Stelle eine diff-ähnliche Zusammenfassung der Änderungen bereit.“

Modernisierung und Korrektheit von Azure-Skripten

„Aktualisiere dieses Azure-Skript auf die aktuellen Az-Module: Authentifiziere dich mit Connect-AzAccount, wähle das Abonnement/den Kontext aus, erfasse die Ressourcenausgaben in Variablen und verwende unterstützte Parameter für New-AzResourceGroup. Ersetze alle AzureRM-Einsätze. Stelle, soweit möglich, idempotentes Verhalten sicher und füge Tags hinzu. Erläutere alle Parameteränderungen aufgrund von Modulaktualisierungen.“

Leistung und Effizienz überprüfen

„Überprüfe die Logik in <FILE> auf unnötige Schleifen und redundante Cmdlet-Aufrufe. Konsolidiere diese nach Möglichkeit zu einzelnen Abfragen (zum Beispiel einmalige Abfrage von Diensten, dann Projektfelder). Ersetze Aufrufe pro Element durch Batch- oder Pipeline-Operationen. Gib nur erforderliche Eigenschaften zurück und vermeide die Materialisierung ungenutzter Daten. Stelle die optimierte Version und eine kurze Begründung für jede Änderung bereit.“

Refactoring für Modulqualität

„Wandel <FILE> in eine wiederverwendbare Modulfunktion um: Füge die Attribute [CmdletBinding()] und [Parameter()] (Mandatory, ValidateSet/Pattern/Range) hinzu, unterstütze ShouldProcess, Pipeline-Eingabe wo angemessen, strukturierte Ausgabe (PSCustomObject oder typisierte Objekte), ausführliche Protokollierung über Write-Verbose und kommentargestützte Hilfe. Nimm bei Bedarf eine Trennung zwischen öffentlichen und privaten Funktionen vor.“

Dokumentation aus dem Code

„Erstelle eine Markdown-README-Datei für <MODULE> mit: Übersicht, Installation, erforderlichen Modulversionen, Anwendungsbeispielen für jede öffentliche Funktion, Konfigurations- und Umgebungsvariablen, Fehlerbehebung und einem Abschnitt zu Sicherheitsaspekten. Verweise auf die kommentarbasierte Hilfe.“

Fehlerbehandlung und Ausfallsicherheit

„Füge eine robuste Fehlerbehandlung zu <FUNCTION> hinzu: set $ErrorActionPreference innerhalb des Geltungsbereichs, verwende try/catch mit bestimmten Ausnahmetypen, bereinige Ressourcen und gib umsetzbare Fehlermeldungen aus. Stelle sicher, dass alle externen Cmdlets -ErrorAction Stop verwenden, wo dies angemessen ist.“

Ausgaben, die für die kontinuierliche Integration bereit sind

„Erstelle eine CI-Checkliste für dieses Repository: führe PSScriptAnalyzer aus, führe Pester v5 aus, überprüfe, dass keine Geheimnisse übertragen wurden, formatiere mit den PowerShell-Erweiterungseinstellungen und brich bei Analyzer- oder Testfehlern ab. Stelle eine GitHub Actions Workflow-YAML bereit, die bei Push/PR zum Main ausgeführt wird.“

Gezielte Auswahl und Korrektheit von Eigenschaften

„Liste für diese Aufgabe laufende Dienste mit ihren Anmeldekonten in PS7 unter Verwendung von CIM (nicht WMI) auf. Vermeide Schleifen und erneute Abfragen; gib Name, DisplayName, State und StartName als Objekte zurück. Stelle ein minimales, effizientes Snippet und eine einzeilige Erklärung bereit.“

Prompt-Muster für iterative Bearbeitung

„Erläutere, was diese Funktion tut, identifiziere Risiken und veraltete APIs und schlag eine sicherere, PS7-kompatible Neufassung vor. Wende dann die Neufassung an.“

„Schlag ein kleines, inkrementelles Refactoring vor, um die Lesbarkeit und Testbarkeit zu verbessern (max. zehn geänderte Zeilen), und zeig dann ein größeres Refactoring, das die Struktur verbessert (max. 50 Zeilen).“

Stil und Formatierung

„Formatiere <FUNCTION> entsprechend dem PowerShell-Stil neu: 2-facher Einzug, PascalCase für Funktionen, Singularformen für Funktionen, zugelassene Verben, konsistente Parameterreihenfolge (-Name, -Id, -Path usw.) und eine Pipeline pro Zeile. Ändere nicht die Logik, sondern nur Formatierung und Benennung, sofern dies unbedenklich ist.“

Wenn Sie Copilot bitten, Code zu ändern, geben Sie die Datei an und schreiben Sie „Änderungen auf diese Datei anwenden“, damit es eine Inline-Bearbeitung vorschlägt. Wenn es abweicht, wiederholen Sie die Einschränkungen und korrigieren Sie einmal. Der nächste Vorschlag entspricht in der Regel Ihren Vorgaben.

So nutzen Sie GitHub Copilot optimal

GitHub Copilot ist mittlerweile ein zuverlässiger Beschleuniger für PowerShell-Arbeiten. Es ist in der Lage, Skripte aus Beschreibungen in natürlicher Sprache zu erstellen, Legacy-Code zu refaktorisieren und Azure-Automatisierungen zusammenzufügen – solange Sie als Experte die Kontrolle behalten.

Für die tägliche Administration kann VS Code in Kombination mit GitHub Copilot stundenlange Codierung auf wenige Minuten reduzieren. Selbst wenn der erste Entwurf von GitHub Copilot nicht perfekt ist, bringt er Sie oft schon ein gutes Stück weiter, was zu einer erheblichen Zeitersparnis bei alltäglichen Aufgaben führt.

Mit präzisen Prompts, sorgfältiger Überprüfung und routinemäßigen Tests wird GitHub Copilot zu einem zuverlässigen Multiplikator für Skripterstellung, Fehlerbehebung und Azure-Orchestrierung, wenn Sie unter Termindruck arbeiten.