Azure DevOps Tutorial: Anwendungen erstellen, testen und bereitstellen

Einrichten deiner Azure DevOps-Umgebung

Um auf die Azure DevOps-Umgebung zugreifen zu können, musst du zunächst alles einrichten, um die Zusammenarbeit im Team und einen durchgängigen Entwicklungsprozess zu fördern.

Ein Azure DevOps-Konto erstellen

Bevor du Azure DevOps nutzen kannst, musst du ein Konto erstellen. Hier erfährst du, wie du loslegen kannst:

• Besuche die Azure DevOps Website: Gehe zu Azure DevOps und beginne unter mit dem Anmeldeprozess. Klicke auf und beginne mit Azure.

• Melde dich mit deinem Microsoft-Konto an: Wenn du bereits ein Microsoft-Konto hast (z. B. Outlook, Xbox, Office 365), kannst du dich damit anmelden. Wenn nicht, musst du ein kostenloses Microsoft-Konto erstellen.
• Klicke auf Anmelden oder Erstelle einen! (Melde dich an).
• Verwende deine Microsoft-Anmeldedaten oder andere Anmeldeoptionen, um dich anzumelden.
• Klicke auf Nächste.

• Starte den Einrichtungsprozess: Klicke auf das Kontrollkästchen und fahre fort. Nach dem Einloggen wirst du aufgefordert, eine neue Organisation zu erstellen. Deine Azure DevOps-Teams und -Projekte sind in dieser Organisation untergebracht. 

Erstellen einer Organisation in Azure DevOps

Eine Organisation in Azure DevOps ist der Ort, an dem sich alle deine Projekte und Repositories befinden. Hier verwaltest du auch deine Teams, Berechtigungen und Rechnungen.

• Nenne deine Organisation: Wähle einen einzigartigen Namen für deine Organisation. Dies ist wichtig, weil sie als Teil deiner Azure DevOps URL erscheint (z.B. https://dev.azure.com/yourorganization ).
• Wähle deine Region: Für Azure DevOps musst du eine Region auswählen, in der deine Daten gespeichert werden sollen. Die Standardregion sollte für die meisten funktionieren, aber wenn du besondere Anforderungen hast, wie z. B. Beschwerden, kannst du eine andere Region wählen, die näher an deiner Nutzerbasis liegt (z. B. die Vereinigten Staaten).
• Bestätige und fahre fort: Nachdem du diese Angaben gemacht hast, klicke auf Weiter. Deine Organisation ist nun startklar und du wirst zum Azure DevOps-Portal weitergeleitet!

Erkundung der Azure DevOps-Schnittstelle

Nachdem du deine Organisation erstellt hast, wirst du zum Azure DevOps-Portal weitergeleitet. Die Hauptbereiche der Dienste sind die Übersicht, Boards, Repos, Pipelines, Testpläne und Artefakte.

Diese Benutzeroberfläche mag sich zunächst überwältigend anfühlen, aber die Kernfunktionen von Azure DevOps lassen sich auf Versionskontrolle, CI/CD und Projektmanagement zusammenfassen.

Ein neues Projekt erstellen

Jetzt, wo dein Konto und deine Organisation eingerichtet sind, können wir dein erstes Projekt für Azure DevOps erstellen.

Ein neues Projekt einrichten

• Klicke auf "Neues Projekt": Im Azure DevOps-Portal klickst du auf die SchaltflächeNeues Projekt. So kannst du dein erstes Projekt einrichten.
• Fülle die Projektdetails aus:
• Projektname: Wähle einen Namen für dein Projekt (z.B. "yourproject").
• Beschreibung (optional): Beschreibe kurz, worum es in diesem Projekt geht.
• Sichtbarkeit: Wähle, ob dein Projekt öffentlich oder privat sein soll. Jeder kann öffentliche Projekte einsehen, was es zu einer hervorragenden Wahl für Open-Source-Projekte macht. Private Projekte sind gesichert und nur für diejenigen zugänglich, die du zu dem Projekt einlädst.
• Erstelle das Projekt: Nachdem du deine Projektdetails eingegeben und das Versionskontrollsystem ausgewählt hast, klicke auf Projekt erstellen. Dein Projekt ist jetzt eingerichtet und startklar!

• Versionskontrollsystem: Azure DevOps bietet zwei Arten von Versionskontrollsystemen: Git und Team Foundation Version Control (TFVC).
• Git ist ein verteiltes Versionskontrollsystem, das moderner ist und in der Entwicklergemeinschaft weit verbreitet ist. Es ist die beste Wahl für die meisten Projekte.
• TFVC ist ein zentralisiertes Versionskontrollsystem, aber es ist weniger verbreitet und wird oft in Legacy-Projekten eingesetzt.

Meiner Erfahrung nach würde ich dir raten, Git zu wählen, wenn du gerade erst anfängst oder keinen besonderen Grund hast, dich für TFVC zu entscheiden.

Bist du bereit, die Kontrolle über deinenCode zu übernehmen? Lerne Git undbeginne deine Projekte wie ein Profi zu verwalten.

Azure Repos für die Versionskontrolle nutzen

Jetzt, wo du dein Projekt fertiggestellt hast, wollen wir es genauer unter die Lupe nehmen und einige seiner wichtigsten Funktionen erkunden.

Einrichten eines Git-Repositorys

• Navigiere zu Repos: Wähle im Menü auf der linken Seite die RegisterkarteRepos. Hier wirst du deinen Code verwalten.

• Klone das Repository: Du kannst das Repository auf deinen lokalen Computer klonen, indem du die URL im Abschnitt Repos angibst, z.B.

# This command clones the specified Git repository from Azure DevOps to your local machine.
git clone https://yourorganization@dev.azure.com/yourorganization/yourproject/_git/yourrepo

Zerlegen wir den obigen Befehl in einzelne Abschnitte:

• Ersetze yourorganization durch den Namen deiner Organisation.
• Ersetze yourproject durch den Namen deines Projekts.
• Ersetze yourrepo durch den Namen deines Repositorys.

Unten findest du die URL in meinem Repos-Bereich:

• Pushe deinen Code: Sobald dein Repository lokal geklont ist, kannst du deinen Code hinzufügen und ihn zurück zu Azure DevOps pushen.

git add .
git commit -m "my first commit"
git push origin main

Herzlichen Glückwunsch! Du hast gerade deinen ersten Commit in Azure Repos gemacht.

Verzweigung und Zusammenführung

In der Softwareentwicklung ermöglicht dir das Branching, an Features oder Korrekturen getrennt vom Hauptprojekt zu arbeiten. Beim Zusammenführen werden deine Änderungen von einem Zweig in einen anderen gebracht.

• Erstelle einen lokalen Zweig: Um mit der Arbeit an einem Feature zu beginnen, erstellst du einen neuen Zweig: 

git checkout -b feature-branch

• Schiebe den Zweig zu Azure DevOps: Nachdem du Änderungen an deinem neuen Zweig vorgenommen hast, schiebe ihn zu Azure DevOps:

git push origin feature-branch

Wechseln zwischen Zweigen

Um zwischen den Zweigen zu wechseln, verwende den folgenden Befehl:

git checkout main

Oder zu einem anderen Zweig zu wechseln:

git checkout feature-branch

Löschen eines Zweigs

Sobald ein Feature zusammengeführt wurde, kannst du den Zweig sowohl lokal als auch aus der Ferne löschen:

• Um den lokalen Zweig zu löschen: 

git branch -d feature-branch

• Um den entfernten Zweig zu löschen:

git push origin --delete feature-branch

Zusammenführen von Zweigen über Pull Requests

• Erstelle einen Pull Request: Sobald dein Funktionszweig mit dem Hauptzweig zusammengeführt werden soll, gehst du in Azure DevOps zum Abschnitt Pull Requests und klickst auf New Pull Request.

• Überprüfen und zusammenführen: Überprüfe die Änderungen und klicke auf Fertig stellen, um die Änderungen im Hauptzweig zusammenzuführen.
• Löse Konflikte: Wenn es Konflikte bei der Zusammenführung gibt (d.h. Änderungen im gleichen Teil des Codes), musst du sie manuell lösen. Azure DevOps wird dich durch diesen Prozess führen, indem es die Konfliktbereiche aufzeigt.

Pull Requests verwalten

Pull-Requests sind wichtig für die Überprüfung des Codes und die Zusammenarbeit. Sie ermöglichen es Teammitgliedern, den Code zu überprüfen, bevor er in den Hauptzweig eingefügt wird.

Einen Pull Request erstellen

• Erstelle den Pull Request: Nachdem du deinen Feature-Branch gepusht hast, navigiere zu Pull Requests und klicke auf New Pull Request. Wähle den Quellzweig (z.B. feature-branch ) und den Zielzweig (z.B. main ).
• Beschreibe den Pull Request: Beschreibe genau, welche Änderungen in dem Pull Request enthalten sind. Das hilft den Prüfern zu verstehen, worauf sie achten müssen.

Überprüfen und Genehmigen von Pull Requests

• Bewertungen anfordern: Füge Reviewer aus deinem Team hinzu, die die Codeänderungen überprüfen.
• Genehmigen und zusammenführen: Sobald die Pull-Anfrage genehmigt ist, klicke auf Abschließen um ihn mit dem Hauptzweig zusammenzuführen.

CI/CD-Pipelines erstellen und verwalten

Azure DevOps umfasst auch Pipelines, um den Build-, Test- und Bereitstellungsprozess zu automatisieren.

Was ist eine Pipeline in Azure DevOps?

Eine Pipeline in Azure DevOps ist eine Sammlung von automatisierten Prozessen, die dir helfen:

• Erstelle deinen Code (Build-Pipeline)
• Teste es
• Verteile sie in verschiedenen Umgebungen (Release Pipeline)

Diese Pipelines sorgen dafür, dass dein Code immer einsatzbereit ist und automatisch getestet werden kann.

Erstellen einer Build-Pipeline

• Navigiere zu Pipelines: Klicken Sie in Ihrem Azure DevOps-Projekt auf Neue Pipeline im Bereich Pipelines Abschnitt.

• Wähle eine Quelle: Wähle Azure Repos Git als Quelle und wähle dein Repository aus.

• Konfiguriere die Pipeline: Du kannst deine Pipeline entweder mit dem YAML-Editor oder dem klassischen Editorkonfigurieren . Nehmen wir YAML, eine codebasierte Methode, um die Pipeline zu definieren.

Nehmen wir eine einfache Node.js-Anwendung als Beispiel. Unsere azure-pipelines.yml Datei unten enthält den YAML-Code, den Azure DevOps automatisch erstellt hat .

# Node.js
# Build a general Node.js project with npm.
# Add steps that analyze code, save build artifacts, deploy, and more:
# https://docs.microsoft.com/azure/devops/pipelines/languages/javascript

trigger:
- main

pool:
  vmImage: ubuntu-latest

steps:
- task: NodeTool@0
  inputs:
    versionSpec: '20.x'
  displayName: 'Install Node.js'

- script: |
    npm install
    npm run build
  displayName: 'npm install and build'

• Speichern und ausführen: Speichere die Pipeline und führe sie aus, um zu sehen, ob alles richtig funktioniert.

Ausführen der Build-Pipeline

Sobald deine Build-Pipeline eingerichtet ist, kannst du sie manuell ausführen, indem du auf Pipeline ausführen klickst. Die Pipeline durchläuft verschiedene Phasen, wie z.B. "Abhängigkeiten installieren", "Tests durchführen" und "Bauen".

Du kannst die Protokolle für jeden Schritt überprüfen, um Fehler bei fehlgeschlagenen Builds zu beheben. Azure DevOps stellt detaillierte Protokolle zur Verfügung, damit du herausfinden kannst, was schief gelaufen ist.

Einrichten der kontinuierlichen Bereitstellung (CD)

• Navigiere zu Veröffentlichungen: Klicke im Abschnitt Pipelines auf Releases und dann auf New Pipeline.

• Füge ein Artefakt hinzu: Verknüpfe das Artefakt aus deiner Build-Pipeline als Quelle für die Release-Pipeline.

• In Umgebungen bereitstellen: Richte Umgebungen wie Staging und Production ein, in denen du deine Anwendung bereitstellen möchtest.

Einsätze automatisieren

Azure DevOps kann deine Anwendung automatisch bereitstellen, sobald ein neuer Build ausgelöst wird. Du kannst dies einrichten, indem du Auslöser hinzufügst und Aufgaben für die Bereitstellung auf Plattformen wie Azure, AWS usw. definierst.

Arbeitsaufgaben mit Azure Boards verwalten

Azure Boards ist das Herzstück des Projektmanagements in Azure DevOps. Mit Funktionen wie Tasks, Bugs, User Stories und Epics können Teams ihre Arbeit über den gesamten Lebenszyklus der Softwareentwicklung hinweg planen, verfolgen und diskutieren. 

Ob nach Scrum oder Kanban, mit Azure Boards kannst du deine Arbeit visualisieren, priorisieren und effizient verwalten.

Lass uns Schritt für Schritt vorgehen.

Arbeitsaufgaben erstellen und verwalten

Mit Azure Boards kannst du Aufgaben, Bugs und Features mit Hilfe von Arbeitsaufgaben verwalten.

• Erstelle ein Workitem: Gehe zu Boards, wähle Work Items und klicke auf New Work Item.

Du kannst erstellen:

• Episch: Ein großes Projekt oder eine umfangreiche Arbeit, die mehrere kleinere Teile umfasst.
• Ausgabe: Ein bestimmtes Problem oder einen Fehler, der behoben werden muss.
• Aufgabe: Ein einzelnes, umsetzbares Stück Arbeit, das erledigt werden muss.

• Wählen wir Epic. 
• Gib einen Titel, eine Beschreibung, eine Priorität, ein Startdatum und ein Zieldatum ein. Klicke auf Speichern.

• Arbeitsaufgaben zuweisen
• Öffne das Workitem, das du gerade erstellt hast. 
• Wähle im Feld " Personen zuweisen " ein Teammitglied aus. 
• Wähle Tag hinzufügen für eine bessere Kategorisierung. Klicke auf Speichern.

• Fortschritte verfolgen
• Verwende das Feld Status, um den Status zu aktualisieren (z.B. Neu, Aktiv, Gelöst, Geschlossen). 
• Füge Kommentare oder Anhänge hinzu, um Aktualisierungen oder Kontext zu liefern.

Meiner Erfahrung nach bleiben Teams verantwortungsbewusst und fokussiert, wenn klare Verantwortliche zugewiesen und angemessene Fristen festgelegt werden.

Sprints und Backlogs einrichten

Agile Sprints und Backlogs sind für die iterative Entwicklung unerlässlich. Hier erfährst du, wie du sie einrichtest:

• Sprints erstellen: Sprints sind zeitlich begrenzte Wiederholungen der Arbeit. Du kannst Sprints einrichten, indem du zu Boards > Sprints gehst und neue Sprints hinzufügst (z.B. "Sprint 1").

• Klicke auf Teameinstellungen konfigurieren und lege deine Sprintdauer fest (z.B. 2 Wochen).

• Füge Start- und Enddaten für den Sprint hinzu.

• Verwalte Produktrückstände: In der Backlog-Ansicht kannst du deine Arbeitsaufgaben nach Prioritäten ordnen. Navigiere zu Boards > Backlogs. 

• Ziehe Arbeitsaufgaben per Drag & Drop in das Backlog, um sie zu priorisieren. 

• Visualisiere den Fortschritt: Azure DevOps hilft dir dabei, Arbeitsaufgaben zu visualisieren und sie über verschiedene Stufen zu verschieben (z.B. To Do, Doing, Done). Verwende die Board-Ansicht, um die Arbeitsaufgaben in Spalten zu sehen. 

• Passe die Spalten an die Arbeitsabläufe deines Teams an.

Meiner Erfahrung nach führt dies dazu, dass dein Team weniger Ausfallzeiten und Verwirrung hat, wenn dein Backlog gut organisiert ist und klar ist, was als Nächstes getan werden muss.

Verknüpfung von Arbeitsaufgaben mit Commits

Die Verknüpfung von Arbeitsaufgaben mit Commits hilft dabei, die Codeänderungen für jede Aufgabe oder jeden Fehler zu verfolgen. Und so geht's:

• Link zu einem Commit: Das kannst du auf zwei Arten tun: über deine Azure DevOps-Konsole oder deine lokale Entwicklungsumgebung.
• Azure DevOps Konsole: Gib in deiner Git-Commit-Nachricht die #WorkItemID an (z. B. #1). Klicke auf Commit. Azure DevOps verknüpft den Commit automatisch mit dem Work Item.

• Lokale Entwicklungsumgebung:
• Öffne in deiner lokalen Entwicklungsumgebung das Terminal oder die Eingabeaufforderung. Nimm deine Codeänderungen vor und bereite dich darauf vor, sie zu übertragen.
• In der Commit-Nachricht gibst du die Workitem-ID mit einem Hashtag an (z. B., Fixed bug in login analytics #1).
• Schließe die Übertragung ab, indem du den entsprechenden Befehl ausführst:

git commit -m "Fixed bug in login analytics #1"

• Pushe die Übergabe an das Remote-Repository (Azure Repo):

git push origin feature-branch

• Link zu einem Pull Request:
  • Wenn du einen Pull Request erstellst, gib die Workitem-ID in der Beschreibung.
  • Klicke auf Erstellen. Azure DevOps verknüpft den Pull Request automatisch mit dem Work Item.

Meiner Erfahrung nach bietet diese Verknüpfung eine vollständige Rückverfolgbarkeit, so dass man leicht erkennen kann, welche Codeänderungen bestimmte Aufgaben oder Fehler behoben haben. Vergiss nicht, dass du verlinkte Commits und PRs im Abschnitt Entwicklung des Workitems sehen kannst.

Integration mit anderen Tools

Azure DevOps glänzt durch die Integration mit anderen Tools wie GitHub und Cloud-Plattformen. Lass uns herausfinden, wie du das einrichten kannst.

Integration von Azure DevOps mit GitHub

Die Verbindung von Azure DevOps mit GitHub optimiert die Zusammenarbeit und CI/CD-Automatisierung. Und so geht's: 

• Verbinde GitHub mit Azure Pipelines: 
• Gehe zu Pipelines > erstellen. Pipeline.

• Wähle GitHub als Quelle.

• Autorisiere Azure DevOps für den Zugriff auf deine GitHub-Repositories.

Neu bei GitHub? Entdecke mit dem Lernpfad GitHub, wie du zusammenarbeitest, Änderungen verfolgst und zu Open-Source-Projekten beiträgst. GitHub-Konzepte-Kurs.

• Eine Pipeline einrichten 
  • Wähle ein Repository und konfiguriere deine YAML-Pipeline-Datei. 

• Definiere die Build- und Deployment-Schritte. Beispiel YAML:

# Set up the trigger for the pipeline
trigger:  
  # Specify the branches to include
  branches:  
    include:  
      # Include the main branch
      - main  

# Define the jobs for the pipeline
jobs:  
  # Create a job named 'Build'
  - job: Build  
    # List the steps for the 'Build' job
    steps:  
      # Add a script step to print a message
      - script: echo "Building the project..." 

Meiner Erfahrung nach sorgt diese Integration automatisch für nahtlose Code-Aktualisierungen und -Einführungen und reduziert den manuellen Aufwand.

Verbindung von Azure DevOps mit Azure und anderen Cloud-Plattformen

Azure DevOps lässt sich nativ mit Azure-Diensten wie Azure Web Apps, Azure Kubernetes Services (AKS) und vielen anderen integrieren. Wir wollen lernen, wie wir Azure DevOps mit Azure Web Apps verbinden können.

• Link zu Azure Services:
  • Gehe unten links in deinem Projekt auf Projekteinstellungen und klicke unter dem Abschnitt Pipelines auf Serviceverbindungen. 

• • Klicke auf Neue Serviceverbindung und wähle Azure Resource Manager. 

• • Authentifiziere dich mit deinem Azure-Konto.
• Auf Azure bereitstellen 
  • Gehe zurück zu deinen Pipelines und konfiguriere deine Pipeline.
  • Füge in deiner Pipeline eine Aufgabe zur Bereitstellung in Azure hinzu. 
  • Gib die Ressourcengruppe und die Dienstdetails an. Beispiel Aufgabe YAML:

# Define the task for deploying to an Azure Web App
- task: AzureWebApp@1  
  inputs:  
    # Specify your Azure subscription service connection
    azureSubscription: 'Your-Service-Connection'  
    # Specify the name of your web app
    appName: 'Your-Web-App' 

Zerlegen wir den obigen Befehl in einzelne Abschnitte: 

• Ersetze Your-Service-Connection durch den Namen der Serviceverbindung mit Zugriff auf dein Azure-Abonnement.
• Ersetze Your-Web-App durch den tatsächlichen Namen deiner Web-App in Azure.

Meiner Erfahrung nach vereinfacht diese Verbindung die Implementierung, so dass du dich hauptsächlich auf die Entwicklung hervorragender Software konzentrieren kannst.

Überwachung und Berichterstattung in Azure DevOps

Überwachung und Berichterstattung sind wichtige Prozesse, um den Zustand deines Projekts in Azure DevOps zu erhalten. Lasst uns herausfinden, wie man das effektiv umsetzen kann.

Anzeigen der Pipeline-Metriken

Pipeline-Metriken geben Aufschluss über die Leistung von Builds und Deployments. So kommst du an sie heran.

• Den Zustand der Pipeline überwachen 
  • Gehe zu Pipelines > Analysen.
  • Sieh dir Kennzahlen wie die Durchlaufrate der Pipeline, die Durchlaufrate der Tests und die Dauer der Pipeline an.

• Engpässe identifizieren 
  • Um Fehlerstufen und langsame Builds zu finden, verwenden Sie die Pipeline-Läufe Bericht.

• • Navigiere zu deinen Azure DevOps Organisation Einstellungen > Pipelines > Parallele Aufträge um parallelisierte Aufträge zu verwenden, um die Leistung zu verbessern und Aufgaben zu optimieren.

Meiner Erfahrung nach können das Zwischenspeichern von Abhängigkeiten, das Aufteilen von Jobs und die Optimierung der Pipelinestruktur die Erstellungszeiten und Fehlerquoten erheblich reduzieren.

Azure DevOps Berichte verwenden

Azure DevOps bietet robuste Reporting-Tools, um die Produktivität des Teams und den Projektfortschritt zu verfolgen.

• Zugang zu Berichten 
  • Gehe zu Analytik > Berichte.
  • Wähle aus vorgefertigten Berichten wie Kumulative Flow Diagramme, Velocity oder Burndown.

• Berichte anpassen 
  • Nutze Power BI, um eigene Dashboards zu erstellen. Verwende dazu den Power BI Data Connector, navigate zu Power BI Online und meldedich bei deinem Konto an.
  • Klick die Startseite in der oberen linken Ecke und wähle dann Daten abrufen aus dem Menüband.
  • Im FensterDaten abrufen siehst du eine Liste der Datenquellen . Wähle Online Services > Azure DevOps (nur Boards) als deinen Daten-Connector.

• Gib deine Kontodaten ein, wie zum Beispiel deine Organisation und Team-Projekt Namen, um deine Daten zu synchronisieren.

• Exportiere Daten für weitere Analysen.

Meiner Erfahrung nach kannst du mit diesen Analyseberichten, die praktische Einblicke bieten, datengestützte Entscheidungen treffen.

Best Practices für Azure DevOps

Nachdem wir nun die Kerndienste von Azure DevOps und viele weitere kennengelernt haben, wollen wir uns ansehen, wie du das Beste aus Azure DevOps herausholen kannst, indem du diese Best Practices befolgst.

Bewährte Praktiken der Versionskontrolle

• Verzweigungsstrategien anwenden 
• Indem du Git Flow oder GitHub Flow zum Verzweigen verwendest. 
• Halte den main Zweig immer stabil und verwende die Feature-Zweige für die Entwicklung.
• Schreibe klare Commit-Meldungen 
• Verwende das Format: type(scope): description (z. B. feat(login): add user authentication ).
• Pull Requests überprüfen 
• Verlangt mindestens einen Reviewer, bevor ihr eure Pull Requests zusammenführt. 
• Nutze Kommentare, um Verbesserungen vorzuschlagen.

Eine saubere und wiederverwendbare Codebasis ist das Ergebnis einer guten Versionskontrolle.

Pipelines optimieren

• Verwende Cache-Abhängigkeiten: Das wiederholte Herunterladen der gleichen Abhängigkeiten kann bei der Arbeit mit Paketmanagern viel Zeit kosten. Azure DevOps unterstützt Caching-Mechanismen, wie z. B. die Cache-Aufgabe, mit der du Abhängigkeiten zwischen Pipeline-Läufen zwischenspeichern kannst. 

Beispiel für die Cache-Aufgabe YAML:

# Define the cache task
- task: Cache@2  
  inputs:  
    # Set the cache key using npm, the OS, and package-lock.json
    key: 'npm | "$(Agent.OS)" | package-lock.json'  
    # Specify the path to the node_modules directory
    path: 'node_modules'

• Jobs aufteilen: Zerlege riesige Aufgaben in kleinere, parallele Aufgaben. Stell dir vor, du hast ein großes Arbeitspensum zu bewältigen, das viel Zeit in Anspruch nimmt. Wenn du sie in einzelne Aufgaben aufteilst, kannst du sie gleichzeitig ausführen, was den gesamten Vorgang beschleunigt.

Beispiel Jobs YAML:

jobs:
  # Define the first build job
  - job: BuildJob1
    displayName: 'Build Job 1'
    pool:
      vmImage: 'ubuntu-latest'
    steps:
      # Add a script step to print a message for Building Project A
      - script: echo "Building Project A"
        displayName: 'Build Project A'

  # Define the second build job
  - job: BuildJob2
    displayName: 'Build Job 2'
    pool:
      vmImage: 'ubuntu-latest'
    steps:
      # Add a script step to print a message for Building Project B
      - script: echo "Building Project B"
        displayName: 'Build Project B'

  # Define the test job
  - job: TestJob
    displayName: 'Run Tests'
    # Specify that this job depends on the completion of BuildJob1 and BuildJob2
    dependsOn: 
      - BuildJob1
      - BuildJob2
    pool:
      vmImage: 'ubuntu-latest'
    steps:
      # Add a script step to print a message for Running Tests
      - script: echo "Running Tests"
        displayName: 'Run Tests'

• Verwende Vorlagen: Erstelle wiederverwendbare Pipeline-Vorlagen für alltägliche Aufgaben. Auf diese Weise musst du denselben Code nicht immer wieder neu schreiben. Lass uns eine einfache Vorlage für eine Bauaufgabe erstellen:

Beispielvorlage YAML:

# Define parameters for the pipeline
parameters:
  # Specify a parameter for the build configuration
  - name: buildConfiguration
    type: string
    default: 'Release'

# List the steps for the pipeline
steps:
  # Add a task to run the .NET Core CLI
  - task: DotNetCoreCLI@2
    inputs:
      # Set the command to 'build'
      command: 'build'
      # Pass the build configuration as an argument
      arguments: '--configuration $(buildConfiguration)'

Ich habe festgestellt, dass die Pipeline-Optimierung durchweg zu Zeit- und Ressourceneinsparungen führt.

Geheimnisse und Sicherheit verwalten

• Verwende Azure Key Vault: Speichere sensible Informationen wie API-Schlüssel im Azure Key Vault. Dazu gehst du zum Azure Portal, erstellst einen neuen Key Vault und fügst deine Geheimnisse (z. B. API-Schlüssel) hinzu.

• Gehe zurück zu Azure DevOps und erstelle eine Serviceverbindung zu deinem Azure-Abonnement, damit deine Pipeline auf den Key Vault zugreifen kann.

• Gehe in Azure DevOps zu Pipelines > Bibliothek und erstelle eine neue Variablengruppe. 

• Verbinde die Variablengruppe mit deinem Key Vault, um die Geheimnisse automatisch abzurufen.
• Referenziere Geheimnisse in deinen Pipelines mit Variablengruppen. Beispiel YAML:

# azure-pipelines.yml
trigger:
- main

variables:
- group: my-variable-group  # Reference the variable group that links to the Key Vault

jobs:
- job: BuildJob
  pool:
    vmImage: 'ubuntu-latest'
  steps:
  - script: echo "Using secret from Key Vault."
    env:
      MY_API_KEY: $(my-secret)  # Reference the secret from the variable group
    displayName: 'Print Secret'

Aus dem obigen Beispiel: Es wird auf die Variablengruppe my-variable-group verwiesen, die Geheimnisse aus dem Key Vault enthält. Der Skriptschritt gibt eine Nachricht aus, die das Geheimnis der Variablengruppe $(my-secret) als Umgebungsvariable verwendet.

• Berechtigungen einschränken 
  • Denke immer daran, den Zugriff auf Pipelines und Repositories rollenbasiert zu beschränken.

Eine wichtige Praxis in der modernen Softwareentwicklung ist die Sicherheit. Sicherheit ist nicht verhandelbar und darf nicht gefährdet werden, weil es um die Konsequenzen geht. 

Fazit

In diesem Tutorial lernten wir, wie man eine Azure DevOps-Umgebung einrichtet, Azure Repos für die Versionskontrolle nutzt, CI/CD-Pipelines erstellt und verwaltet, Arbeitselemente mit Azure Boards verfolgt und verwaltet, Azure DevOps mit anderen Tools integriert, Best Practices für Azure DevOps und mehr.

Beständigkeit ist das Geheimnis des Erfolgs. Überprüfe deine Prozesse regelmäßig, hol dir Feedback und nimm Anpassungen vor. Wenn du diese beherrschst, kannst du dein volles Potenzial als Datenprofi in der Softwareentwicklung ausschöpfen. Entdecke Azure DevOps, probiere diese Tools aus und sieh, wie viel produktiver dein Team ist.

Wenn du tiefer in Microsoft Azure eintauchen willst, schau dir die folgenden Kurse an: 

• Microsoft Azure verstehen - Schaffe dir eine solide Grundlage in Microsoft Azure und nutze die Möglichkeiten des Cloud Computing.
• Microsoft Azure Grundlagen (AZ-900) - Mach dich mit diesem einsteigerfreundlichen Lernpfad, der alle wichtigen Azure-Grundlagen abdeckt, fit für die Prüfung.
• Die Architektur und Dienste von Microsoft Azure verstehen - Lerne, wie die Architektur und die Dienste von Azure zusammenarbeiten, um Cloud-Lösungen zu ermöglichen.